| /* |
| * 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 "generate_ndk.h" |
| |
| #include "aidl.h" |
| #include "aidl_language.h" |
| #include "aidl_to_cpp_common.h" |
| #include "aidl_to_ndk.h" |
| |
| #include <android-base/logging.h> |
| |
| namespace android { |
| namespace aidl { |
| namespace ndk { |
| |
| static constexpr const char* kClazz = "_g_aidl_clazz"; |
| static constexpr const char* kDescriptor = "descriptor"; |
| static constexpr const char* kVersion = "version"; |
| static constexpr const char* kCacheVariable = "_aidl_cached_value"; |
| |
| using namespace internals; |
| using cpp::ClassNames; |
| |
| void GenerateNdkInterface(const string& output_file, const Options& options, |
| const AidlTypenames& types, const AidlInterface& defined_type, |
| const IoDelegate& io_delegate) { |
| const string i_header = options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::RAW); |
| unique_ptr<CodeWriter> i_writer(io_delegate.GetCodeWriter(i_header)); |
| GenerateInterfaceHeader(*i_writer, types, defined_type, options); |
| CHECK(i_writer->Close()); |
| |
| const string bp_header = |
| options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::CLIENT); |
| unique_ptr<CodeWriter> bp_writer(io_delegate.GetCodeWriter(bp_header)); |
| GenerateClientHeader(*bp_writer, types, defined_type, options); |
| CHECK(bp_writer->Close()); |
| |
| const string bn_header = |
| options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::SERVER); |
| unique_ptr<CodeWriter> bn_writer(io_delegate.GetCodeWriter(bn_header)); |
| GenerateServerHeader(*bn_writer, types, defined_type, options); |
| CHECK(bn_writer->Close()); |
| |
| unique_ptr<CodeWriter> source_writer = io_delegate.GetCodeWriter(output_file); |
| GenerateSource(*source_writer, types, defined_type, options); |
| CHECK(source_writer->Close()); |
| } |
| |
| void GenerateNdkParcel(const string& output_file, const Options& options, |
| const AidlTypenames& types, const AidlStructuredParcelable& defined_type, |
| const IoDelegate& io_delegate) { |
| const string header_path = |
| options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::RAW); |
| unique_ptr<CodeWriter> header_writer(io_delegate.GetCodeWriter(header_path)); |
| GenerateParcelHeader(*header_writer, types, defined_type, options); |
| CHECK(header_writer->Close()); |
| |
| const string bp_header = |
| options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::CLIENT); |
| unique_ptr<CodeWriter> bp_writer(io_delegate.GetCodeWriter(bp_header)); |
| *bp_writer << "#error TODO(b/111362593) defined_types do not have bp classes\n"; |
| CHECK(bp_writer->Close()); |
| |
| const string bn_header = |
| options.OutputHeaderDir() + NdkHeaderFile(defined_type, ClassNames::SERVER); |
| unique_ptr<CodeWriter> bn_writer(io_delegate.GetCodeWriter(bn_header)); |
| *bn_writer << "#error TODO(b/111362593) defined_types do not have bn classes\n"; |
| CHECK(bn_writer->Close()); |
| |
| unique_ptr<CodeWriter> source_writer = io_delegate.GetCodeWriter(output_file); |
| GenerateParcelSource(*source_writer, types, defined_type, options); |
| CHECK(source_writer->Close()); |
| } |
| |
| void GenerateNdkParcelDeclaration(const std::string& filename, const IoDelegate& io_delegate) { |
| CodeWriterPtr code_writer = io_delegate.GetCodeWriter(filename); |
| *code_writer |
| << "// This file is intentionally left blank as placeholder for parcel declaration.\n"; |
| CHECK(code_writer->Close()); |
| } |
| |
| void GenerateNdk(const string& output_file, const Options& options, const AidlTypenames& types, |
| const AidlDefinedType& defined_type, const IoDelegate& io_delegate) { |
| const AidlStructuredParcelable* parcelable = defined_type.AsStructuredParcelable(); |
| if (parcelable != nullptr) { |
| GenerateNdkParcel(output_file, options, types, *parcelable, io_delegate); |
| return; |
| } |
| |
| const AidlParcelable* parcelable_decl = defined_type.AsParcelable(); |
| if (parcelable_decl != nullptr) { |
| GenerateNdkParcelDeclaration(output_file, io_delegate); |
| return; |
| } |
| |
| const AidlInterface* interface = defined_type.AsInterface(); |
| if (interface != nullptr) { |
| GenerateNdkInterface(output_file, options, types, *interface, io_delegate); |
| return; |
| } |
| |
| CHECK(false) << "Unrecognized type sent for cpp generation."; |
| } |
| namespace internals { |
| |
| void EnterNdkNamespace(CodeWriter& out, const AidlDefinedType& defined_type) { |
| out << "namespace aidl {\n"; |
| cpp::EnterNamespace(out, defined_type); |
| } |
| void LeaveNdkNamespace(CodeWriter& out, const AidlDefinedType& defined_type) { |
| cpp::LeaveNamespace(out, defined_type); |
| out << "} // namespace aidl\n"; |
| } |
| |
| static void StatusCheckGoto(CodeWriter& out) { |
| out << "if (_aidl_ret_status != STATUS_OK) goto _aidl_error;\n\n"; |
| } |
| static void StatusCheckBreak(CodeWriter& out) { |
| out << "if (_aidl_ret_status != STATUS_OK) break;\n\n"; |
| } |
| static void StatusCheckReturn(CodeWriter& out) { |
| out << "if (_aidl_ret_status != STATUS_OK) return _aidl_ret_status;\n\n"; |
| } |
| |
| static void GenerateHeaderIncludes(CodeWriter& out, const AidlTypenames& types, |
| const AidlDefinedType& defined_type) { |
| out << "#include <android/binder_parcel_utils.h>\n"; |
| |
| types.IterateTypes([&](const AidlDefinedType& other_defined_type) { |
| if (&other_defined_type == &defined_type) return; |
| |
| if (other_defined_type.AsInterface() != nullptr) { |
| out << "#include <" |
| << NdkHeaderFile(other_defined_type, ClassNames::RAW, false /*use_os_sep*/) << ">\n"; |
| } else if (other_defined_type.AsStructuredParcelable() != nullptr) { |
| out << "#include <" |
| << NdkHeaderFile(other_defined_type, ClassNames::BASE, false /*use_os_sep*/) << ">\n"; |
| } else if (other_defined_type.AsParcelable() != nullptr) { |
| out << "#include \"" << other_defined_type.AsParcelable()->GetCppHeader() << "\"\n"; |
| } else { |
| AIDL_FATAL(defined_type) << "Unrecognized type."; |
| } |
| }); |
| } |
| static void GenerateSourceIncludes(CodeWriter& out, const AidlTypenames& types, |
| const AidlDefinedType& /*defined_type*/) { |
| types.IterateTypes([&](const AidlDefinedType& a_defined_type) { |
| if (a_defined_type.AsInterface() != nullptr) { |
| out << "#include <" << NdkHeaderFile(a_defined_type, ClassNames::CLIENT, false /*use_os_sep*/) |
| << ">\n"; |
| out << "#include <" << NdkHeaderFile(a_defined_type, ClassNames::SERVER, false /*use_os_sep*/) |
| << ">\n"; |
| out << "#include <" << NdkHeaderFile(a_defined_type, ClassNames::RAW, false /*use_os_sep*/) |
| << ">\n"; |
| } |
| }); |
| } |
| |
| static void GenerateConstantDeclarations(CodeWriter& out, const AidlInterface& interface) { |
| for (const auto& constant : interface.GetConstantDeclarations()) { |
| const AidlConstantValue& value = constant->GetValue(); |
| if (value.GetType() == AidlConstantValue::Type::STRING) { |
| out << "static const char* " << constant->GetName() << ";\n"; |
| } |
| } |
| out << "\n"; |
| |
| bool hasIntegralConstant = false; |
| for (const auto& constant : interface.GetConstantDeclarations()) { |
| const AidlConstantValue& value = constant->GetValue(); |
| if (value.GetType() == AidlConstantValue::Type::HEXIDECIMAL || |
| value.GetType() == AidlConstantValue::Type::INTEGRAL) { |
| hasIntegralConstant = true; |
| break; |
| } |
| } |
| |
| if (hasIntegralConstant) { |
| out << "enum : int32_t {\n"; |
| out.Indent(); |
| for (const auto& constant : interface.GetConstantDeclarations()) { |
| const AidlConstantValue& value = constant->GetValue(); |
| if (value.GetType() == AidlConstantValue::Type::HEXIDECIMAL || |
| value.GetType() == AidlConstantValue::Type::INTEGRAL) { |
| out << constant->GetName() << " = " << constant->ValueString(AidlConstantValueDecorator) |
| << ",\n"; |
| } |
| } |
| out.Dedent(); |
| out << "};\n"; |
| } |
| } |
| static void GenerateConstantDefinitions(CodeWriter& out, const AidlInterface& interface) { |
| const std::string clazz = ClassName(interface, ClassNames::INTERFACE); |
| |
| for (const auto& constant : interface.GetConstantDeclarations()) { |
| const AidlConstantValue& value = constant->GetValue(); |
| if (value.GetType() == AidlConstantValue::Type::STRING) { |
| out << "const char* " << clazz << "::" << constant->GetName() << " = " |
| << constant->ValueString(AidlConstantValueDecorator) << ";\n"; |
| } |
| } |
| } |
| |
| void GenerateSource(CodeWriter& out, const AidlTypenames& types, const AidlInterface& defined_type, |
| const Options& options) { |
| GenerateSourceIncludes(out, types, defined_type); |
| out << "\n"; |
| |
| EnterNdkNamespace(out, defined_type); |
| GenerateClassSource(out, types, defined_type, options); |
| GenerateClientSource(out, types, defined_type, options); |
| GenerateServerSource(out, types, defined_type, options); |
| GenerateInterfaceSource(out, types, defined_type, options); |
| LeaveNdkNamespace(out, defined_type); |
| } |
| |
| static std::string MethodId(const AidlMethod& m) { |
| return "(FIRST_CALL_TRANSACTION + " + std::to_string(m.GetId()) + " /*" + m.GetName() + "*/)"; |
| } |
| |
| static void GenerateClientMethodDefinition(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, |
| const AidlMethod& method, |
| const std::optional<std::string> return_value_cached_to, |
| const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::CLIENT); |
| |
| out << NdkMethodDecl(types, method, clazz) << " {\n"; |
| out.Indent(); |
| out << "binder_status_t _aidl_ret_status = STATUS_OK;\n"; |
| out << "::ndk::ScopedAStatus _aidl_status;\n"; |
| |
| if (return_value_cached_to) { |
| out << "if (" << *return_value_cached_to << " != -1) {\n"; |
| out.Indent(); |
| out << "*_aidl_return = " << *return_value_cached_to << ";\n" |
| << "_aidl_status.set(AStatus_fromStatus(_aidl_ret_status));\n" |
| << "return _aidl_status;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } |
| out << "::ndk::ScopedAParcel _aidl_in;\n"; |
| out << "::ndk::ScopedAParcel _aidl_out;\n"; |
| out << "\n"; |
| |
| if (options.GenLog()) { |
| out << cpp::GenLogBeforeExecute(ClassName(defined_type, ClassNames::CLIENT), method, |
| false /* isServer */, true /* isNdk */); |
| } |
| |
| out << "_aidl_ret_status = AIBinder_prepareTransaction(asBinder().get(), _aidl_in.getR());\n"; |
| StatusCheckGoto(out); |
| |
| for (const auto& arg : method.GetArguments()) { |
| const std::string var_name = cpp::BuildVarName(*arg); |
| |
| if (arg->IsIn()) { |
| out << "_aidl_ret_status = "; |
| const std::string prefix = (arg->IsOut() ? "*" : ""); |
| WriteToParcelFor({out, types, arg->GetType(), "_aidl_in.get()", prefix + var_name}); |
| out << ";\n"; |
| StatusCheckGoto(out); |
| } else if (arg->IsOut() && arg->GetType().IsArray()) { |
| out << "_aidl_ret_status = ::ndk::AParcel_writeVectorSize(_aidl_in.get(), *" << var_name |
| << ");\n"; |
| } |
| } |
| out << "_aidl_ret_status = AIBinder_transact(\n"; |
| out.Indent(); |
| out << "asBinder().get(),\n"; |
| out << MethodId(method) << ",\n"; |
| out << "_aidl_in.getR(),\n"; |
| out << "_aidl_out.getR(),\n"; |
| out << (method.IsOneway() ? "FLAG_ONEWAY" : "0") << ");\n"; |
| out.Dedent(); |
| |
| // If the method is not implmented in the server side but the client has |
| // provided the default implementation, call it instead of failing hard. |
| const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); |
| out << "if (_aidl_ret_status == STATUS_UNKNOWN_TRANSACTION && "; |
| out << iface << "::getDefaultImpl()) {\n"; |
| out.Indent(); |
| out << "return " << iface << "::getDefaultImpl()->" << method.GetName() << "("; |
| out << NdkArgList(types, method, FormatArgNameOnly) << ");\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| StatusCheckGoto(out); |
| |
| if (!method.IsOneway()) { |
| out << "_aidl_ret_status = AParcel_readStatusHeader(_aidl_out.get(), _aidl_status.getR());\n"; |
| StatusCheckGoto(out); |
| |
| out << "if (!AStatus_isOk(_aidl_status.get())) return _aidl_status;\n\n"; |
| } |
| |
| if (method.GetType().GetName() != "void") { |
| out << "_aidl_ret_status = "; |
| ReadFromParcelFor({out, types, method.GetType(), "_aidl_out.get()", "_aidl_return"}); |
| out << ";\n"; |
| StatusCheckGoto(out); |
| if (return_value_cached_to) { |
| out << *return_value_cached_to << " = *_aidl_return;\n"; |
| } |
| } |
| for (const AidlArgument* arg : method.GetOutArguments()) { |
| out << "_aidl_ret_status = "; |
| ReadFromParcelFor({out, types, arg->GetType(), "_aidl_out.get()", cpp::BuildVarName(*arg)}); |
| out << ";\n"; |
| StatusCheckGoto(out); |
| } |
| |
| out << "_aidl_error:\n"; |
| out << "_aidl_status.set(AStatus_fromStatus(_aidl_ret_status));\n"; |
| if (options.GenLog()) { |
| out << cpp::GenLogAfterExecute(ClassName(defined_type, ClassNames::CLIENT), defined_type, |
| method, "_aidl_status", "_aidl_return", false /* isServer */, |
| true /* isNdk */); |
| } |
| out << "return _aidl_status;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } |
| |
| static void GenerateServerCaseDefinition(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, |
| const AidlMethod& method, const Options& options) { |
| out << "case " << MethodId(method) << ": {\n"; |
| out.Indent(); |
| for (const auto& arg : method.GetArguments()) { |
| out << NdkNameOf(types, arg->GetType(), StorageMode::STACK) << " " << cpp::BuildVarName(*arg) |
| << ";\n"; |
| } |
| if (method.GetType().GetName() != "void") { |
| out << NdkNameOf(types, method.GetType(), StorageMode::STACK) << " _aidl_return;\n"; |
| } |
| out << "\n"; |
| |
| for (const auto& arg : method.GetArguments()) { |
| const std::string var_name = cpp::BuildVarName(*arg); |
| |
| if (arg->IsIn()) { |
| out << "_aidl_ret_status = "; |
| ReadFromParcelFor({out, types, arg->GetType(), "_aidl_in", "&" + var_name}); |
| out << ";\n"; |
| StatusCheckBreak(out); |
| } else if (arg->IsOut() && arg->GetType().IsArray()) { |
| out << "_aidl_ret_status = ::ndk::AParcel_resizeVector(_aidl_in, &" << var_name << ");\n"; |
| } |
| } |
| if (options.GenLog()) { |
| out << cpp::GenLogBeforeExecute(ClassName(defined_type, ClassNames::SERVER), method, |
| true /* isServer */, true /* isNdk */); |
| } |
| out << "::ndk::ScopedAStatus _aidl_status = _aidl_impl->" << method.GetName() << "(" |
| << NdkArgList(types, method, FormatArgForCall) << ");\n"; |
| |
| if (options.GenLog()) { |
| out << cpp::GenLogAfterExecute(ClassName(defined_type, ClassNames::SERVER), defined_type, |
| method, "_aidl_status", "_aidl_return", true /* isServer */, |
| true /* isNdk */); |
| } |
| if (method.IsOneway()) { |
| // For a oneway transaction, the kernel will have already returned a result. This is for the |
| // in-process case when a oneway transaction is parceled/unparceled in the same process. |
| out << "_aidl_ret_status = STATUS_OK;\n"; |
| } else { |
| out << "_aidl_ret_status = AParcel_writeStatusHeader(_aidl_out, _aidl_status.get());\n"; |
| StatusCheckBreak(out); |
| |
| out << "if (!AStatus_isOk(_aidl_status.get())) break;\n\n"; |
| |
| if (method.GetType().GetName() != "void") { |
| out << "_aidl_ret_status = "; |
| WriteToParcelFor({out, types, method.GetType(), "_aidl_out", "_aidl_return"}); |
| out << ";\n"; |
| StatusCheckBreak(out); |
| } |
| for (const AidlArgument* arg : method.GetOutArguments()) { |
| out << "_aidl_ret_status = "; |
| WriteToParcelFor({out, types, arg->GetType(), "_aidl_out", cpp::BuildVarName(*arg)}); |
| out << ";\n"; |
| StatusCheckBreak(out); |
| } |
| } |
| out << "break;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } |
| |
| void GenerateClassSource(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::INTERFACE); |
| const std::string bn_clazz = ClassName(defined_type, ClassNames::SERVER); |
| |
| out << "static binder_status_t " |
| << "_aidl_onTransact" |
| << "(AIBinder* _aidl_binder, transaction_code_t _aidl_code, const AParcel* _aidl_in, " |
| "AParcel* _aidl_out) {\n"; |
| out.Indent(); |
| out << "(void)_aidl_in;\n"; |
| out << "(void)_aidl_out;\n"; |
| out << "binder_status_t _aidl_ret_status = STATUS_UNKNOWN_TRANSACTION;\n"; |
| if (!defined_type.GetMethods().empty()) { |
| // we know this cast is valid because this method is only called by the ICInterface |
| // AIBinder_Class object which is associated with this class. |
| out << "std::shared_ptr<" << bn_clazz << "> _aidl_impl = std::static_pointer_cast<" << bn_clazz |
| << ">(::ndk::ICInterface::asInterface(_aidl_binder));\n"; |
| out << "switch (_aidl_code) {\n"; |
| out.Indent(); |
| for (const auto& method : defined_type.GetMethods()) { |
| GenerateServerCaseDefinition(out, types, defined_type, *method, options); |
| } |
| out.Dedent(); |
| out << "}\n"; |
| } else { |
| out << "(void)_aidl_binder;\n"; |
| out << "(void)_aidl_code;\n"; |
| } |
| out << "return _aidl_ret_status;\n"; |
| out.Dedent(); |
| out << "};\n\n"; |
| |
| out << "static AIBinder_Class* " << kClazz << " = ::ndk::ICInterface::defineClass(" << clazz |
| << "::" << kDescriptor << ", _aidl_onTransact);\n\n"; |
| } |
| void GenerateClientSource(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::CLIENT); |
| |
| out << clazz << "::" << clazz << "(const ::ndk::SpAIBinder& binder) : BpCInterface(binder) {}\n"; |
| out << clazz << "::~" << clazz << "() {}\n"; |
| if (options.GenLog()) { |
| out << "std::function<void(const Json::Value&)> " << clazz << "::logFunc;\n"; |
| } |
| out << "\n"; |
| for (const auto& method : defined_type.GetMethods()) { |
| // Only getInterfaceVersion can use cache. |
| const bool cacheable = !method->IsUserDefined() && method->GetName() == kGetInterfaceVersion && |
| options.Version() > 0; |
| const auto return_value_cached_to = |
| cacheable ? std::make_optional<std::string>(kCacheVariable) : std::nullopt; |
| GenerateClientMethodDefinition(out, types, defined_type, *method, return_value_cached_to, |
| options); |
| } |
| } |
| void GenerateServerSource(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::SERVER); |
| const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); |
| |
| out << "// Source for " << clazz << "\n"; |
| out << clazz << "::" << clazz << "() {}\n"; |
| out << clazz << "::~" << clazz << "() {}\n"; |
| if (options.GenLog()) { |
| out << "std::function<void(const Json::Value&)> " << clazz << "::logFunc;\n"; |
| } |
| out << "::ndk::SpAIBinder " << clazz << "::createBinder() {\n"; |
| out.Indent(); |
| out << "AIBinder* binder = AIBinder_new(" << kClazz << ", static_cast<void*>(this));\n"; |
| out << "return ::ndk::SpAIBinder(binder);\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| // Implement the meta methods |
| for (const auto& method : defined_type.GetMethods()) { |
| if (method->IsUserDefined()) { |
| continue; |
| } |
| if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { |
| out << NdkMethodDecl(types, *method, clazz) << " {\n"; |
| out.Indent(); |
| out << "*_aidl_return = " << iface << "::" << kVersion << ";\n"; |
| out << "return ::ndk::ScopedAStatus(AStatus_newOk());\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } |
| } |
| } |
| void GenerateInterfaceSource(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::INTERFACE); |
| const std::string bp_clazz = ClassName(defined_type, ClassNames::CLIENT); |
| |
| out << "// Source for " << clazz << "\n"; |
| out << "const char* " << clazz << "::" << kDescriptor << " = \"" |
| << defined_type.GetCanonicalName() << "\";\n"; |
| out << clazz << "::" << clazz << "() {}\n"; |
| out << clazz << "::~" << clazz << "() {}\n"; |
| out << "\n"; |
| GenerateConstantDefinitions(out, defined_type); |
| out << "\n"; |
| |
| out << "std::shared_ptr<" << clazz << "> " << clazz |
| << "::fromBinder(const ::ndk::SpAIBinder& binder) {\n"; |
| out.Indent(); |
| out << "if (!AIBinder_associateClass(binder.get(), " << kClazz << ")) { return nullptr; }\n"; |
| out << "std::shared_ptr<::ndk::ICInterface> interface = " |
| "::ndk::ICInterface::asInterface(binder.get());\n"; |
| out << "if (interface) {\n"; |
| out.Indent(); |
| out << "return std::static_pointer_cast<" << clazz << ">(interface);\n"; |
| out.Dedent(); |
| out << "}\n"; |
| out << "return (new " << bp_clazz << "(binder))->ref<" << clazz << ">();\n"; |
| out.Dedent(); |
| out << "}\n\n"; |
| |
| out << "binder_status_t " << clazz << "::writeToParcel(AParcel* parcel, const std::shared_ptr<" |
| << clazz << ">& instance) {\n"; |
| out.Indent(); |
| out << "return AParcel_writeStrongBinder(parcel, instance ? instance->asBinder().get() : " |
| "nullptr);\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| out << "binder_status_t " << clazz << "::readFromParcel(const AParcel* parcel, std::shared_ptr<" |
| << clazz << ">* instance) {\n"; |
| out.Indent(); |
| out << "::ndk::SpAIBinder binder;\n"; |
| out << "binder_status_t status = AParcel_readStrongBinder(parcel, binder.getR());\n"; |
| out << "if (status != STATUS_OK) return status;\n"; |
| out << "*instance = " << clazz << "::fromBinder(binder);\n"; |
| out << "return STATUS_OK;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| // defintion for static member setDefaultImpl |
| out << "bool " << clazz << "::setDefaultImpl(std::shared_ptr<" << clazz << "> impl) {\n"; |
| out.Indent(); |
| out << "if (!" << clazz << "::default_impl && impl) {\n"; |
| out.Indent(); |
| out << clazz << "::default_impl = impl;\n"; |
| out << "return true;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| out << "return false;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| // definition for static member getDefaultImpl |
| out << "const std::shared_ptr<" << clazz << ">& " << clazz << "::getDefaultImpl() {\n"; |
| out.Indent(); |
| out << "return " << clazz << "::default_impl;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| // definition for the static field default_impl |
| out << "std::shared_ptr<" << clazz << "> " << clazz << "::default_impl = nullptr;\n"; |
| |
| // default implementation for the <Name>Default class members |
| const std::string defaultClazz = clazz + "Default"; |
| for (const auto& method : defined_type.GetMethods()) { |
| if (method->IsUserDefined()) { |
| out << "::ndk::ScopedAStatus " << defaultClazz << "::" << method->GetName() << "(" |
| << NdkArgList(types, *method, FormatArgNameUnused) << ") {\n"; |
| out.Indent(); |
| out << "::ndk::ScopedAStatus _aidl_status;\n"; |
| out << "_aidl_status.set(AStatus_fromStatus(STATUS_UNKNOWN_TRANSACTION));\n"; |
| out << "return _aidl_status;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } else { |
| if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { |
| out << "::ndk::ScopedAStatus " << defaultClazz << "::" << method->GetName() << "(" |
| << "int32_t* _aidl_return) {\n"; |
| out.Indent(); |
| out << "*_aidl_return = 0;\n"; |
| out << "return ::ndk::ScopedAStatus(AStatus_newOk());\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } |
| } |
| } |
| |
| out << "::ndk::SpAIBinder " << defaultClazz << "::asBinder() {\n"; |
| out.Indent(); |
| out << "return ::ndk::SpAIBinder();\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| out << "bool " << defaultClazz << "::isRemote() {\n"; |
| out.Indent(); |
| out << "return false;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| } |
| |
| void GenerateClientHeader(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::CLIENT); |
| |
| out << "#pragma once\n\n"; |
| out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::RAW, false /*use_os_sep*/) |
| << "\"\n"; |
| out << "\n"; |
| out << "#include <android/binder_ibinder.h>\n"; |
| if (options.GenLog()) { |
| out << "#include <json/value.h>\n"; |
| out << "#include <functional>\n"; |
| out << "#include <chrono>\n"; |
| out << "#include <sstream>\n"; |
| } |
| out << "\n"; |
| EnterNdkNamespace(out, defined_type); |
| out << "class " << clazz << " : public ::ndk::BpCInterface<" |
| << ClassName(defined_type, ClassNames::INTERFACE) << "> {\n"; |
| out << "public:\n"; |
| out.Indent(); |
| out << clazz << "(const ::ndk::SpAIBinder& binder);\n"; |
| out << "virtual ~" << clazz << "();\n"; |
| out << "\n"; |
| for (const auto& method : defined_type.GetMethods()) { |
| out << NdkMethodDecl(types, *method) << " override;\n"; |
| } |
| |
| if (options.Version() > 0) { |
| out << "int32_t " << kCacheVariable << " = -1;\n"; |
| } |
| if (options.GenLog()) { |
| out << "static std::function<void(const Json::Value&)> logFunc;\n"; |
| } |
| out.Dedent(); |
| out << "};\n"; |
| LeaveNdkNamespace(out, defined_type); |
| } |
| void GenerateServerHeader(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::SERVER); |
| const std::string iface = ClassName(defined_type, ClassNames::INTERFACE); |
| |
| out << "#pragma once\n\n"; |
| out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::RAW, false /*use_os_sep*/) |
| << "\"\n"; |
| out << "\n"; |
| out << "#include <android/binder_ibinder.h>\n"; |
| out << "\n"; |
| EnterNdkNamespace(out, defined_type); |
| out << "class " << clazz << " : public ::ndk::BnCInterface<" << iface << "> {\n"; |
| out << "public:\n"; |
| out.Indent(); |
| out << clazz << "();\n"; |
| out << "virtual ~" << clazz << "();\n"; |
| |
| // Declare the meta methods |
| for (const auto& method : defined_type.GetMethods()) { |
| if (method->IsUserDefined()) { |
| continue; |
| } |
| if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { |
| out << NdkMethodDecl(types, *method) << " final override;\n"; |
| } else { |
| AIDL_FATAL(defined_type) << "Meta method '" << method->GetName() << "' is unimplemented."; |
| } |
| } |
| if (options.GenLog()) { |
| out << "static std::function<void(const Json::Value&)> logFunc;\n"; |
| } |
| out.Dedent(); |
| out << "protected:\n"; |
| out.Indent(); |
| out << "::ndk::SpAIBinder createBinder() override;\n"; |
| out.Dedent(); |
| out << "private:\n"; |
| out.Indent(); |
| out.Dedent(); |
| out << "};\n"; |
| LeaveNdkNamespace(out, defined_type); |
| } |
| void GenerateInterfaceHeader(CodeWriter& out, const AidlTypenames& types, |
| const AidlInterface& defined_type, const Options& options) { |
| const std::string clazz = ClassName(defined_type, ClassNames::INTERFACE); |
| |
| out << "#pragma once\n\n"; |
| out << "#include <android/binder_interface_utils.h>\n"; |
| if (options.GenLog()) { |
| out << "#include <json/value.h>\n"; |
| out << "#include <functional>\n"; |
| out << "#include <chrono>\n"; |
| out << "#include <sstream>\n"; |
| } |
| out << "\n"; |
| |
| GenerateHeaderIncludes(out, types, defined_type); |
| out << "\n"; |
| |
| EnterNdkNamespace(out, defined_type); |
| out << "class " << clazz << " : public ::ndk::ICInterface {\n"; |
| out << "public:\n"; |
| out.Indent(); |
| out << "static const char* " << kDescriptor << ";\n"; |
| out << clazz << "();\n"; |
| out << "virtual ~" << clazz << "();\n"; |
| out << "\n"; |
| GenerateConstantDeclarations(out, defined_type); |
| if (options.Version() > 0) { |
| out << "static const int32_t " << kVersion << " = " << std::to_string(options.Version()) |
| << ";\n"; |
| } |
| out << "\n"; |
| out << "static std::shared_ptr<" << clazz << "> fromBinder(const ::ndk::SpAIBinder& binder);\n"; |
| out << "static binder_status_t writeToParcel(AParcel* parcel, const std::shared_ptr<" << clazz |
| << ">& instance);"; |
| out << "\n"; |
| out << "static binder_status_t readFromParcel(const AParcel* parcel, std::shared_ptr<" << clazz |
| << ">* instance);"; |
| out << "\n"; |
| out << "static bool setDefaultImpl(std::shared_ptr<" << clazz << "> impl);"; |
| out << "\n"; |
| out << "static const std::shared_ptr<" << clazz << ">& getDefaultImpl();"; |
| out << "\n"; |
| for (const auto& method : defined_type.GetMethods()) { |
| out << "virtual " << NdkMethodDecl(types, *method) << " = 0;\n"; |
| } |
| out.Dedent(); |
| out << "private:\n"; |
| out.Indent(); |
| out << "static std::shared_ptr<" << clazz << "> default_impl;\n"; |
| out.Dedent(); |
| out << "};\n"; |
| |
| const std::string defaultClazz = clazz + "Default"; |
| |
| out << "class " << defaultClazz << " : public " << clazz << " {\n"; |
| out << "public:\n"; |
| out.Indent(); |
| for (const auto& method : defined_type.GetMethods()) { |
| if (method->IsUserDefined()) { |
| out << NdkMethodDecl(types, *method) << " override;\n"; |
| } else if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) { |
| out << NdkMethodDecl(types, *method) << " override;\n"; |
| } |
| } |
| out << "::ndk::SpAIBinder asBinder() override;\n"; |
| out << "bool isRemote() override;\n"; |
| out.Dedent(); |
| out << "};\n"; |
| |
| LeaveNdkNamespace(out, defined_type); |
| } |
| void GenerateParcelHeader(CodeWriter& out, const AidlTypenames& types, |
| const AidlStructuredParcelable& defined_type, |
| const Options& /*options*/) { |
| const std::string clazz = ClassName(defined_type, ClassNames::BASE); |
| |
| out << "#pragma once\n"; |
| out << "#include <android/binder_interface_utils.h>\n"; |
| out << "\n"; |
| |
| GenerateHeaderIncludes(out, types, defined_type); |
| |
| EnterNdkNamespace(out, defined_type); |
| out << "class " << clazz << " {\n"; |
| out << "public:\n"; |
| out.Indent(); |
| out << "static const char* descriptor;\n"; |
| out << "\n"; |
| for (const auto& variable : defined_type.GetFields()) { |
| out << NdkNameOf(types, variable->GetType(), StorageMode::STACK) << " " << variable->GetName(); |
| if (variable->GetDefaultValue()) { |
| out << " = " << variable->ValueString(AidlConstantValueDecorator); |
| } |
| out << ";\n"; |
| } |
| out << "\n"; |
| out << "binder_status_t readFromParcel(const AParcel* parcel);\n"; |
| out << "binder_status_t writeToParcel(AParcel* parcel) const;\n"; |
| out.Dedent(); |
| out << "};\n"; |
| LeaveNdkNamespace(out, defined_type); |
| } |
| void GenerateParcelSource(CodeWriter& out, const AidlTypenames& types, |
| const AidlStructuredParcelable& defined_type, |
| const Options& /*options*/) { |
| const std::string clazz = ClassName(defined_type, ClassNames::BASE); |
| |
| out << "#include \"" << NdkHeaderFile(defined_type, ClassNames::RAW, false /*use_os_sep*/) |
| << "\"\n"; |
| out << "\n"; |
| GenerateSourceIncludes(out, types, defined_type); |
| out << "\n"; |
| EnterNdkNamespace(out, defined_type); |
| out << "const char* " << clazz << "::" << kDescriptor << " = \"" |
| << defined_type.GetCanonicalName() << "\";\n"; |
| out << "\n"; |
| |
| out << "binder_status_t " << clazz << "::readFromParcel(const AParcel* parcel) {\n"; |
| out.Indent(); |
| out << "std::string _aidl_descriptor;\n"; |
| out << "binder_status_t _aidl_ret_status;\n"; |
| |
| out << "int32_t _aidl_null;\n"; |
| out << "int32_t _aidl_parcelable_size;\n"; |
| out << "int32_t _aidl_start_pos;\n"; |
| out << "_aidl_ret_status = AParcel_readInt32(parcel, &_aidl_null);\n"; |
| StatusCheckReturn(out); |
| out << "_aidl_start_pos = AParcel_getDataPosition(parcel);\n"; |
| out << "_aidl_ret_status = AParcel_readInt32(parcel, &_aidl_parcelable_size);\n"; |
| out << "if (_aidl_parcelable_size < 0) return STATUS_BAD_VALUE;\n"; |
| StatusCheckReturn(out); |
| |
| // TODO(b/117281836) |
| out << "if (_aidl_null == 0) return STATUS_UNEXPECTED_NULL;\n\n"; |
| |
| for (const auto& variable : defined_type.GetFields()) { |
| out << "_aidl_ret_status = "; |
| ReadFromParcelFor({out, types, variable->GetType(), "parcel", "&" + variable->GetName()}); |
| out << ";\n"; |
| StatusCheckReturn(out); |
| out << "if (AParcel_getDataPosition(parcel) - _aidl_start_pos >= _aidl_parcelable_size) {\n" |
| << " AParcel_setDataPosition(parcel, _aidl_start_pos + _aidl_parcelable_size);\n" |
| << " return _aidl_ret_status;\n" |
| << "}\n"; |
| } |
| out << "AParcel_setDataPosition(parcel, _aidl_start_pos + _aidl_parcelable_size);\n" |
| << "return _aidl_ret_status;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| |
| out << "binder_status_t " << clazz << "::writeToParcel(AParcel* parcel) const {\n"; |
| out.Indent(); |
| out << "binder_status_t _aidl_ret_status;\n"; |
| |
| // non-null |
| out << "_aidl_ret_status = AParcel_writeInt32(parcel, 1);\n"; |
| StatusCheckReturn(out); |
| out << "size_t _aidl_start_pos = AParcel_getDataPosition(parcel);\n"; |
| out << "_aidl_ret_status = AParcel_writeInt32(parcel, 0);\n"; |
| StatusCheckReturn(out); |
| |
| for (const auto& variable : defined_type.GetFields()) { |
| out << "_aidl_ret_status = "; |
| WriteToParcelFor({out, types, variable->GetType(), "parcel", variable->GetName()}); |
| out << ";\n"; |
| StatusCheckReturn(out); |
| } |
| out << "size_t _aidl_end_pos = AParcel_getDataPosition(parcel);\n"; |
| out << "AParcel_setDataPosition(parcel, _aidl_start_pos);\n"; |
| out << "AParcel_writeInt32(parcel, _aidl_end_pos - _aidl_start_pos);\n"; |
| out << "AParcel_setDataPosition(parcel, _aidl_end_pos);\n"; |
| |
| out << "return _aidl_ret_status;\n"; |
| out.Dedent(); |
| out << "}\n"; |
| out << "\n"; |
| LeaveNdkNamespace(out, defined_type); |
| } |
| } // namespace internals |
| } // namespace ndk |
| } // namespace aidl |
| } // namespace android |