1165 lines
43 KiB
C++
1165 lines
43 KiB
C++
/*
|
|
* Copyright (C) 2020, 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_rust.h"
|
|
|
|
#include <android-base/stringprintf.h>
|
|
#include <android-base/strings.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <sstream>
|
|
|
|
#include "aidl_to_cpp_common.h"
|
|
#include "aidl_to_rust.h"
|
|
#include "code_writer.h"
|
|
#include "comments.h"
|
|
#include "logging.h"
|
|
|
|
using android::base::Join;
|
|
using android::base::Split;
|
|
using std::ostringstream;
|
|
using std::shared_ptr;
|
|
using std::string;
|
|
using std::unique_ptr;
|
|
using std::vector;
|
|
|
|
namespace android {
|
|
namespace aidl {
|
|
namespace rust {
|
|
|
|
static constexpr const char kArgumentPrefix[] = "_arg_";
|
|
static constexpr const char kGetInterfaceVersion[] = "getInterfaceVersion";
|
|
static constexpr const char kGetInterfaceHash[] = "getInterfaceHash";
|
|
|
|
void GenerateMangledAliases(CodeWriter& out, const AidlDefinedType& type) {
|
|
struct Visitor : AidlVisitor {
|
|
CodeWriter& out;
|
|
Visitor(CodeWriter& out) : out(out) {}
|
|
void Visit(const AidlStructuredParcelable& type) override { VisitType(type); }
|
|
void Visit(const AidlInterface& type) override { VisitType(type); }
|
|
void Visit(const AidlEnumDeclaration& type) override { VisitType(type); }
|
|
void Visit(const AidlUnionDecl& type) override { VisitType(type); }
|
|
void VisitType(const AidlDefinedType& type) {
|
|
out << " pub use " << Qname(type) << " as " << Mangled(type) << ";\n";
|
|
}
|
|
// Return a mangled name for a type (including AIDL package)
|
|
string Mangled(const AidlDefinedType& type) const {
|
|
ostringstream alias;
|
|
for (const auto& component : Split(type.GetCanonicalName(), ".")) {
|
|
alias << "_" << component.size() << "_" << component;
|
|
}
|
|
return alias.str();
|
|
}
|
|
// Return a fully qualified name for a type in the current file (excluding AIDL package)
|
|
string Qname(const AidlDefinedType& type) const { return Module(type) + "::" + type.GetName(); }
|
|
// Return a module name for a type (relative to the file)
|
|
string Module(const AidlDefinedType& type) const {
|
|
if (type.GetParentType()) {
|
|
return Module(*type.GetParentType()) + "::" + type.GetName();
|
|
} else {
|
|
return "super";
|
|
}
|
|
}
|
|
} v(out);
|
|
out << "pub(crate) mod mangled {\n";
|
|
VisitTopDown(v, type);
|
|
out << "}\n";
|
|
}
|
|
|
|
string BuildArg(const AidlArgument& arg, const AidlTypenames& typenames, Lifetime lifetime) {
|
|
// We pass in parameters that are not primitives by const reference.
|
|
// Arrays get passed in as slices, which is handled in RustNameOf.
|
|
auto arg_mode = ArgumentStorageMode(arg, typenames);
|
|
auto arg_type = RustNameOf(arg.GetType(), typenames, arg_mode, lifetime);
|
|
return kArgumentPrefix + arg.GetName() + ": " + arg_type;
|
|
}
|
|
|
|
enum class MethodKind {
|
|
// This is a normal non-async method.
|
|
NORMAL,
|
|
// This is an async method. Identical to NORMAL except that async is added
|
|
// in front of `fn`.
|
|
ASYNC,
|
|
// This is an async function, but using a boxed future instead of the async
|
|
// keyword.
|
|
BOXED_FUTURE,
|
|
// This could have been a non-async method, but it returns a Future so that
|
|
// it would not be breaking to make the function do async stuff in the future.
|
|
READY_FUTURE,
|
|
};
|
|
|
|
string BuildMethod(const AidlMethod& method, const AidlTypenames& typenames,
|
|
const MethodKind kind = MethodKind::NORMAL) {
|
|
// We need to mark the arguments with a lifetime only when returning a future that
|
|
// actually captures the arguments.
|
|
Lifetime lifetime;
|
|
switch (kind) {
|
|
case MethodKind::NORMAL:
|
|
case MethodKind::ASYNC:
|
|
case MethodKind::READY_FUTURE:
|
|
lifetime = Lifetime::NONE;
|
|
break;
|
|
case MethodKind::BOXED_FUTURE:
|
|
lifetime = Lifetime::A;
|
|
break;
|
|
}
|
|
|
|
auto method_type = RustNameOf(method.GetType(), typenames, StorageMode::VALUE, lifetime);
|
|
auto return_type = string{"binder::Result<"} + method_type + ">";
|
|
auto fn_prefix = string{""};
|
|
|
|
switch (kind) {
|
|
case MethodKind::NORMAL:
|
|
// Don't wrap the return type in anything.
|
|
break;
|
|
case MethodKind::ASYNC:
|
|
fn_prefix = "async ";
|
|
break;
|
|
case MethodKind::BOXED_FUTURE:
|
|
return_type = "binder::BoxFuture<'a, " + return_type + ">";
|
|
break;
|
|
case MethodKind::READY_FUTURE:
|
|
return_type = "std::future::Ready<" + return_type + ">";
|
|
break;
|
|
}
|
|
|
|
string parameters = "&" + RustLifetimeName(lifetime) + "self";
|
|
string lifetime_str = RustLifetimeGeneric(lifetime);
|
|
|
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
|
parameters += ", ";
|
|
parameters += BuildArg(*arg, typenames, lifetime);
|
|
}
|
|
|
|
return fn_prefix + "fn " + method.GetName() + lifetime_str + "(" + parameters + ") -> " +
|
|
return_type;
|
|
}
|
|
|
|
void GenerateClientMethodHelpers(CodeWriter& out, const AidlInterface& iface,
|
|
const AidlMethod& method, const AidlTypenames& typenames,
|
|
const Options& options, const std::string& default_trait_name) {
|
|
string parameters = "&self";
|
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
|
parameters += ", ";
|
|
parameters += BuildArg(*arg, typenames, Lifetime::NONE);
|
|
}
|
|
|
|
// Generate build_parcel helper.
|
|
out << "fn build_parcel_" + method.GetName() + "(" + parameters +
|
|
") -> binder::Result<binder::binder_impl::Parcel> {\n";
|
|
out.Indent();
|
|
|
|
out << "let mut aidl_data = self.binder.prepare_transact()?;\n";
|
|
|
|
if (iface.IsSensitiveData()) {
|
|
out << "aidl_data.mark_sensitive();\n";
|
|
}
|
|
|
|
// Arguments
|
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
|
auto arg_name = kArgumentPrefix + arg->GetName();
|
|
if (arg->IsIn()) {
|
|
// If the argument is already a reference, don't reference it again
|
|
// (unless we turned it into an Option<&T>)
|
|
auto ref_mode = ArgumentReferenceMode(*arg, typenames);
|
|
if (IsReference(ref_mode)) {
|
|
out << "aidl_data.write(" << arg_name << ")?;\n";
|
|
} else {
|
|
out << "aidl_data.write(&" << arg_name << ")?;\n";
|
|
}
|
|
} else if (arg->GetType().IsDynamicArray()) {
|
|
// For out-only arrays, send the array size
|
|
if (arg->GetType().IsNullable()) {
|
|
out << "aidl_data.write_slice_size(" << arg_name << ".as_deref())?;\n";
|
|
} else {
|
|
out << "aidl_data.write_slice_size(Some(" << arg_name << "))?;\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
out << "Ok(aidl_data)\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
|
|
// Generate read_response helper.
|
|
auto return_type = RustNameOf(method.GetType(), typenames, StorageMode::VALUE, Lifetime::NONE);
|
|
out << "fn read_response_" + method.GetName() + "(" + parameters +
|
|
", _aidl_reply: std::result::Result<binder::binder_impl::Parcel, "
|
|
"binder::StatusCode>) -> binder::Result<" +
|
|
return_type + "> {\n";
|
|
out.Indent();
|
|
|
|
// Check for UNKNOWN_TRANSACTION and call the default impl
|
|
if (method.IsUserDefined()) {
|
|
string default_args;
|
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
|
if (!default_args.empty()) {
|
|
default_args += ", ";
|
|
}
|
|
default_args += kArgumentPrefix;
|
|
default_args += arg->GetName();
|
|
}
|
|
out << "if let Err(binder::StatusCode::UNKNOWN_TRANSACTION) = _aidl_reply {\n";
|
|
out << " if let Some(_aidl_default_impl) = <Self as " << default_trait_name
|
|
<< ">::getDefaultImpl() {\n";
|
|
out << " return _aidl_default_impl." << method.GetName() << "(" << default_args << ");\n";
|
|
out << " }\n";
|
|
out << "}\n";
|
|
}
|
|
|
|
// Return all other errors
|
|
out << "let _aidl_reply = _aidl_reply?;\n";
|
|
|
|
string return_val = "()";
|
|
if (!method.IsOneway()) {
|
|
// Check for errors
|
|
out << "let _aidl_status: binder::Status = _aidl_reply.read()?;\n";
|
|
out << "if !_aidl_status.is_ok() { return Err(_aidl_status); }\n";
|
|
|
|
// Return reply value
|
|
if (method.GetType().GetName() != "void") {
|
|
auto return_type =
|
|
RustNameOf(method.GetType(), typenames, StorageMode::VALUE, Lifetime::NONE);
|
|
out << "let _aidl_return: " << return_type << " = _aidl_reply.read()?;\n";
|
|
return_val = "_aidl_return";
|
|
|
|
if (!method.IsUserDefined()) {
|
|
if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
|
out << "self.cached_version.store(_aidl_return, std::sync::atomic::Ordering::Relaxed);\n";
|
|
}
|
|
if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) {
|
|
out << "*self.cached_hash.lock().unwrap() = Some(_aidl_return.clone());\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const AidlArgument* arg : method.GetOutArguments()) {
|
|
out << "_aidl_reply.read_onto(" << kArgumentPrefix << arg->GetName() << ")?;\n";
|
|
}
|
|
}
|
|
|
|
// Return the result
|
|
out << "Ok(" << return_val << ")\n";
|
|
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateClientMethod(CodeWriter& out, const AidlInterface& iface, const AidlMethod& method,
|
|
const AidlTypenames& typenames, const Options& options,
|
|
const MethodKind kind) {
|
|
// Generate the method
|
|
out << BuildMethod(method, typenames, kind) << " {\n";
|
|
out.Indent();
|
|
|
|
if (!method.IsUserDefined()) {
|
|
if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
|
// Check if the version is in the cache
|
|
out << "let _aidl_version = "
|
|
"self.cached_version.load(std::sync::atomic::Ordering::Relaxed);\n";
|
|
switch (kind) {
|
|
case MethodKind::NORMAL:
|
|
case MethodKind::ASYNC:
|
|
out << "if _aidl_version != -1 { return Ok(_aidl_version); }\n";
|
|
break;
|
|
case MethodKind::BOXED_FUTURE:
|
|
out << "if _aidl_version != -1 { return Box::pin(std::future::ready(Ok(_aidl_version))); "
|
|
"}\n";
|
|
break;
|
|
case MethodKind::READY_FUTURE:
|
|
out << "if _aidl_version != -1 { return std::future::ready(Ok(_aidl_version)); }\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (method.GetName() == kGetInterfaceHash && !options.Hash().empty()) {
|
|
out << "{\n";
|
|
out << " let _aidl_hash_lock = self.cached_hash.lock().unwrap();\n";
|
|
out << " if let Some(ref _aidl_hash) = *_aidl_hash_lock {\n";
|
|
switch (kind) {
|
|
case MethodKind::NORMAL:
|
|
case MethodKind::ASYNC:
|
|
out << " return Ok(_aidl_hash.clone());\n";
|
|
break;
|
|
case MethodKind::BOXED_FUTURE:
|
|
out << " return Box::pin(std::future::ready(Ok(_aidl_hash.clone())));\n";
|
|
break;
|
|
case MethodKind::READY_FUTURE:
|
|
out << " return std::future::ready(Ok(_aidl_hash.clone()));\n";
|
|
break;
|
|
}
|
|
out << " }\n";
|
|
out << "}\n";
|
|
}
|
|
}
|
|
|
|
string build_parcel_args;
|
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
|
if (!build_parcel_args.empty()) {
|
|
build_parcel_args += ", ";
|
|
}
|
|
build_parcel_args += kArgumentPrefix;
|
|
build_parcel_args += arg->GetName();
|
|
}
|
|
|
|
string read_response_args =
|
|
build_parcel_args.empty() ? "_aidl_reply" : build_parcel_args + ", _aidl_reply";
|
|
|
|
vector<string> flags;
|
|
if (method.IsOneway()) flags.push_back("binder::binder_impl::FLAG_ONEWAY");
|
|
if (iface.IsSensitiveData()) flags.push_back("binder::binder_impl::FLAG_CLEAR_BUF");
|
|
flags.push_back("binder::binder_impl::FLAG_PRIVATE_LOCAL");
|
|
|
|
string transact_flags = flags.empty() ? "0" : Join(flags, " | ");
|
|
|
|
switch (kind) {
|
|
case MethodKind::NORMAL:
|
|
case MethodKind::ASYNC:
|
|
// Prepare transaction.
|
|
out << "let _aidl_data = self.build_parcel_" + method.GetName() + "(" + build_parcel_args +
|
|
")?;\n";
|
|
// Submit transaction.
|
|
out << "let _aidl_reply = self.binder.submit_transact(transactions::" << method.GetName()
|
|
<< ", _aidl_data, " << transact_flags << ");\n";
|
|
// Deserialize response.
|
|
out << "self.read_response_" + method.GetName() + "(" + read_response_args + ")\n";
|
|
break;
|
|
case MethodKind::READY_FUTURE:
|
|
// Prepare transaction.
|
|
out << "let _aidl_data = match self.build_parcel_" + method.GetName() + "(" +
|
|
build_parcel_args + ") {\n";
|
|
out.Indent();
|
|
out << "Ok(_aidl_data) => _aidl_data,\n";
|
|
out << "Err(err) => return std::future::ready(Err(err)),\n";
|
|
out.Dedent();
|
|
out << "};\n";
|
|
// Submit transaction.
|
|
out << "let _aidl_reply = self.binder.submit_transact(transactions::" << method.GetName()
|
|
<< ", _aidl_data, " << transact_flags << ");\n";
|
|
// Deserialize response.
|
|
out << "std::future::ready(self.read_response_" + method.GetName() + "(" +
|
|
read_response_args + "))\n";
|
|
break;
|
|
case MethodKind::BOXED_FUTURE:
|
|
// Prepare transaction.
|
|
out << "let _aidl_data = match self.build_parcel_" + method.GetName() + "(" +
|
|
build_parcel_args + ") {\n";
|
|
out.Indent();
|
|
out << "Ok(_aidl_data) => _aidl_data,\n";
|
|
out << "Err(err) => return Box::pin(std::future::ready(Err(err))),\n";
|
|
out.Dedent();
|
|
out << "};\n";
|
|
// Submit transaction.
|
|
out << "let binder = self.binder.clone();\n";
|
|
out << "P::spawn(\n";
|
|
out.Indent();
|
|
out << "move || binder.submit_transact(transactions::" << method.GetName() << ", _aidl_data, "
|
|
<< transact_flags << "),\n";
|
|
out << "move |_aidl_reply| async move {\n";
|
|
out.Indent();
|
|
// Deserialize response.
|
|
out << "self.read_response_" + method.GetName() + "(" + read_response_args + ")\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
out.Dedent();
|
|
out << ")\n";
|
|
break;
|
|
}
|
|
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateServerTransaction(CodeWriter& out, const AidlInterface& interface,
|
|
const AidlMethod& method, const AidlTypenames& typenames) {
|
|
out << "transactions::" << method.GetName() << " => {\n";
|
|
out.Indent();
|
|
|
|
if (interface.EnforceExpression() || method.GetType().EnforceExpression()) {
|
|
out << "compile_error!(\"Permission checks not support for the Rust backend\");\n";
|
|
}
|
|
|
|
string args;
|
|
for (const auto& arg : method.GetArguments()) {
|
|
string arg_name = kArgumentPrefix + arg->GetName();
|
|
StorageMode arg_mode;
|
|
if (arg->IsIn()) {
|
|
arg_mode = StorageMode::VALUE;
|
|
} else {
|
|
// We need a value we can call Default::default() on
|
|
arg_mode = StorageMode::DEFAULT_VALUE;
|
|
}
|
|
auto arg_type = RustNameOf(arg->GetType(), typenames, arg_mode, Lifetime::NONE);
|
|
|
|
string arg_mut = arg->IsOut() ? "mut " : "";
|
|
string arg_init = arg->IsIn() ? "_aidl_data.read()?" : "Default::default()";
|
|
out << "let " << arg_mut << arg_name << ": " << arg_type << " = " << arg_init << ";\n";
|
|
if (!arg->IsIn() && arg->GetType().IsDynamicArray()) {
|
|
// _aidl_data.resize_[nullable_]out_vec(&mut _arg_foo)?;
|
|
auto resize_name = arg->GetType().IsNullable() ? "resize_nullable_out_vec" : "resize_out_vec";
|
|
out << "_aidl_data." << resize_name << "(&mut " << arg_name << ")?;\n";
|
|
}
|
|
|
|
auto ref_mode = ArgumentReferenceMode(*arg, typenames);
|
|
if (!args.empty()) {
|
|
args += ", ";
|
|
}
|
|
args += TakeReference(ref_mode, arg_name);
|
|
}
|
|
out << "let _aidl_return = _aidl_service." << method.GetName() << "(" << args << ");\n";
|
|
|
|
if (!method.IsOneway()) {
|
|
out << "match &_aidl_return {\n";
|
|
out.Indent();
|
|
out << "Ok(_aidl_return) => {\n";
|
|
out.Indent();
|
|
out << "_aidl_reply.write(&binder::Status::from(binder::StatusCode::OK))?;\n";
|
|
if (method.GetType().GetName() != "void") {
|
|
out << "_aidl_reply.write(_aidl_return)?;\n";
|
|
}
|
|
|
|
// Serialize out arguments
|
|
for (const AidlArgument* arg : method.GetOutArguments()) {
|
|
string arg_name = kArgumentPrefix + arg->GetName();
|
|
|
|
auto& arg_type = arg->GetType();
|
|
if (!arg->IsIn() && arg_type.IsArray() && arg_type.GetName() == "ParcelFileDescriptor") {
|
|
// We represent arrays of ParcelFileDescriptor as
|
|
// Vec<Option<ParcelFileDescriptor>> when they're out-arguments,
|
|
// but we need all of them to be initialized to Some; if there's
|
|
// any None, return UNEXPECTED_NULL (this is what libbinder_ndk does)
|
|
out << "if " << arg_name << ".iter().any(Option::is_none) { "
|
|
<< "return Err(binder::StatusCode::UNEXPECTED_NULL); }\n";
|
|
} else if (!arg->IsIn() && TypeNeedsOption(arg_type, typenames)) {
|
|
// Unwrap out-only arguments that we wrapped in Option<T>
|
|
out << "let " << arg_name << " = " << arg_name
|
|
<< ".ok_or(binder::StatusCode::UNEXPECTED_NULL)?;\n";
|
|
}
|
|
|
|
out << "_aidl_reply.write(&" << arg_name << ")?;\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
out << "Err(_aidl_status) => _aidl_reply.write(_aidl_status)?\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
out << "Ok(())\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateServerItems(CodeWriter& out, const AidlInterface* iface,
|
|
const AidlTypenames& typenames) {
|
|
auto trait_name = ClassName(*iface, cpp::ClassNames::INTERFACE);
|
|
auto server_name = ClassName(*iface, cpp::ClassNames::SERVER);
|
|
|
|
// Forward all IFoo functions from Binder to the inner object
|
|
out << "impl " << trait_name << " for binder::binder_impl::Binder<" << server_name << "> {\n";
|
|
out.Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
string args;
|
|
for (const std::unique_ptr<AidlArgument>& arg : method->GetArguments()) {
|
|
if (!args.empty()) {
|
|
args += ", ";
|
|
}
|
|
args += kArgumentPrefix;
|
|
args += arg->GetName();
|
|
}
|
|
out << BuildMethod(*method, typenames) << " { "
|
|
<< "self.0." << method->GetName() << "(" << args << ") }\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
|
|
out << "fn on_transact("
|
|
"_aidl_service: &dyn "
|
|
<< trait_name
|
|
<< ", "
|
|
"_aidl_code: binder::binder_impl::TransactionCode, "
|
|
"_aidl_data: &binder::binder_impl::BorrowedParcel<'_>, "
|
|
"_aidl_reply: &mut binder::binder_impl::BorrowedParcel<'_>) -> std::result::Result<(), "
|
|
"binder::StatusCode> "
|
|
"{\n";
|
|
out.Indent();
|
|
out << "match _aidl_code {\n";
|
|
out.Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
GenerateServerTransaction(out, *iface, *method, typenames);
|
|
}
|
|
out << "_ => Err(binder::StatusCode::UNKNOWN_TRANSACTION)\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateDeprecated(CodeWriter& out, const AidlCommentable& type) {
|
|
if (auto deprecated = FindDeprecated(type.GetComments()); deprecated.has_value()) {
|
|
if (deprecated->note.empty()) {
|
|
out << "#[deprecated]\n";
|
|
} else {
|
|
out << "#[deprecated = " << QuotedEscape(deprecated->note) << "]\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename TypeWithConstants>
|
|
void GenerateConstantDeclarations(CodeWriter& out, const TypeWithConstants& type,
|
|
const AidlTypenames& typenames) {
|
|
for (const auto& constant : type.GetConstantDeclarations()) {
|
|
const AidlTypeSpecifier& type = constant->GetType();
|
|
const AidlConstantValue& value = constant->GetValue();
|
|
|
|
string const_type;
|
|
if (type.Signature() == "String") {
|
|
const_type = "&str";
|
|
} else if (type.Signature() == "byte" || type.Signature() == "int" ||
|
|
type.Signature() == "long") {
|
|
const_type = RustNameOf(type, typenames, StorageMode::VALUE, Lifetime::NONE);
|
|
} else {
|
|
AIDL_FATAL(value) << "Unrecognized constant type: " << type.Signature();
|
|
}
|
|
|
|
GenerateDeprecated(out, *constant);
|
|
out << "pub const " << constant->GetName() << ": " << const_type << " = "
|
|
<< constant->ValueString(ConstantValueDecoratorRef) << ";\n";
|
|
}
|
|
}
|
|
|
|
void GenerateRustInterface(CodeWriter* code_writer, const AidlInterface* iface,
|
|
const AidlTypenames& typenames, const Options& options) {
|
|
*code_writer << "#![allow(non_upper_case_globals)]\n";
|
|
*code_writer << "#![allow(non_snake_case)]\n";
|
|
// Import IBinderInternal for transact()
|
|
*code_writer << "#[allow(unused_imports)] use binder::binder_impl::IBinderInternal;\n";
|
|
|
|
auto trait_name = ClassName(*iface, cpp::ClassNames::INTERFACE);
|
|
auto trait_name_async = trait_name + "Async";
|
|
auto trait_name_async_server = trait_name + "AsyncServer";
|
|
auto client_name = ClassName(*iface, cpp::ClassNames::CLIENT);
|
|
auto server_name = ClassName(*iface, cpp::ClassNames::SERVER);
|
|
*code_writer << "use binder::declare_binder_interface;\n";
|
|
*code_writer << "declare_binder_interface! {\n";
|
|
code_writer->Indent();
|
|
*code_writer << trait_name << "[\"" << iface->GetDescriptor() << "\"] {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "native: " << server_name << "(on_transact),\n";
|
|
*code_writer << "proxy: " << client_name << " {\n";
|
|
code_writer->Indent();
|
|
if (options.Version() > 0) {
|
|
string comma = options.Hash().empty() ? "" : ",";
|
|
*code_writer << "cached_version: "
|
|
"std::sync::atomic::AtomicI32 = "
|
|
"std::sync::atomic::AtomicI32::new(-1)"
|
|
<< comma << "\n";
|
|
}
|
|
if (!options.Hash().empty()) {
|
|
*code_writer << "cached_hash: "
|
|
"std::sync::Mutex<Option<String>> = "
|
|
"std::sync::Mutex::new(None)\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "},\n";
|
|
*code_writer << "async: " << trait_name_async << ",\n";
|
|
if (iface->IsVintfStability()) {
|
|
*code_writer << "stability: binder::binder_impl::Stability::Vintf,\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Emit the trait.
|
|
GenerateDeprecated(*code_writer, *iface);
|
|
*code_writer << "pub trait " << trait_name << ": binder::Interface + Send {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "fn get_descriptor() -> &'static str where Self: Sized { \""
|
|
<< iface->GetDescriptor() << "\" }\n";
|
|
|
|
for (const auto& method : iface->GetMethods()) {
|
|
// Generate the method
|
|
GenerateDeprecated(*code_writer, *method);
|
|
if (method->IsUserDefined()) {
|
|
*code_writer << BuildMethod(*method, typenames) << ";\n";
|
|
} else {
|
|
// Generate default implementations for meta methods
|
|
*code_writer << BuildMethod(*method, typenames) << " {\n";
|
|
code_writer->Indent();
|
|
if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
|
*code_writer << "Ok(VERSION)\n";
|
|
} else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) {
|
|
*code_writer << "Ok(HASH.into())\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
}
|
|
}
|
|
|
|
// Emit the default implementation code inside the trait
|
|
auto default_trait_name = ClassName(*iface, cpp::ClassNames::DEFAULT_IMPL);
|
|
auto default_ref_name = default_trait_name + "Ref";
|
|
*code_writer << "fn getDefaultImpl()"
|
|
<< " -> " << default_ref_name << " where Self: Sized {\n";
|
|
*code_writer << " DEFAULT_IMPL.lock().unwrap().clone()\n";
|
|
*code_writer << "}\n";
|
|
*code_writer << "fn setDefaultImpl(d: " << default_ref_name << ")"
|
|
<< " -> " << default_ref_name << " where Self: Sized {\n";
|
|
*code_writer << " std::mem::replace(&mut *DEFAULT_IMPL.lock().unwrap(), d)\n";
|
|
*code_writer << "}\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Emit the async trait.
|
|
GenerateDeprecated(*code_writer, *iface);
|
|
*code_writer << "pub trait " << trait_name_async << "<P>: binder::Interface + Send {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "fn get_descriptor() -> &'static str where Self: Sized { \""
|
|
<< iface->GetDescriptor() << "\" }\n";
|
|
|
|
for (const auto& method : iface->GetMethods()) {
|
|
// Generate the method
|
|
GenerateDeprecated(*code_writer, *method);
|
|
|
|
MethodKind kind = method->IsOneway() ? MethodKind::READY_FUTURE : MethodKind::BOXED_FUTURE;
|
|
|
|
if (method->IsUserDefined()) {
|
|
*code_writer << BuildMethod(*method, typenames, kind) << ";\n";
|
|
} else {
|
|
// Generate default implementations for meta methods
|
|
*code_writer << BuildMethod(*method, typenames, kind) << " {\n";
|
|
code_writer->Indent();
|
|
if (method->GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
|
*code_writer << "Box::pin(async move { Ok(VERSION) })\n";
|
|
} else if (method->GetName() == kGetInterfaceHash && !options.Hash().empty()) {
|
|
*code_writer << "Box::pin(async move { Ok(HASH.into()) })\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
}
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Emit the async server trait.
|
|
GenerateDeprecated(*code_writer, *iface);
|
|
*code_writer << "#[::async_trait::async_trait]\n";
|
|
*code_writer << "pub trait " << trait_name_async_server << ": binder::Interface + Send {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "fn get_descriptor() -> &'static str where Self: Sized { \""
|
|
<< iface->GetDescriptor() << "\" }\n";
|
|
|
|
for (const auto& method : iface->GetMethods()) {
|
|
// Generate the method
|
|
if (method->IsUserDefined()) {
|
|
GenerateDeprecated(*code_writer, *method);
|
|
*code_writer << BuildMethod(*method, typenames, MethodKind::ASYNC) << ";\n";
|
|
}
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Emit a new_async_binder method for binding an async server.
|
|
*code_writer << "impl " << server_name << " {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "/// Create a new async binder service.\n";
|
|
*code_writer << "pub fn new_async_binder<T, R>(inner: T, rt: R, features: "
|
|
"binder::BinderFeatures) -> binder::Strong<dyn "
|
|
<< trait_name << ">\n";
|
|
*code_writer << "where\n";
|
|
code_writer->Indent();
|
|
*code_writer << "T: " << trait_name_async_server
|
|
<< " + binder::Interface + Send + Sync + 'static,\n";
|
|
*code_writer << "R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static,\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "{\n";
|
|
code_writer->Indent();
|
|
// Define a wrapper struct that implements the non-async trait by calling block_on.
|
|
*code_writer << "struct Wrapper<T, R> {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "_inner: T,\n";
|
|
*code_writer << "_rt: R,\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
*code_writer << "impl<T, R> binder::Interface for Wrapper<T, R> where T: binder::Interface, R: "
|
|
"Send + Sync {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "fn as_binder(&self) -> binder::SpIBinder { self._inner.as_binder() }\n";
|
|
*code_writer
|
|
<< "fn dump(&self, _file: &std::fs::File, _args: &[&std::ffi::CStr]) -> "
|
|
"std::result::Result<(), binder::StatusCode> { self._inner.dump(_file, _args) }\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
*code_writer << "impl<T, R> " << trait_name << " for Wrapper<T, R>\n";
|
|
*code_writer << "where\n";
|
|
code_writer->Indent();
|
|
*code_writer << "T: " << trait_name_async_server << " + Send + Sync + 'static,\n";
|
|
*code_writer << "R: binder::binder_impl::BinderAsyncRuntime + Send + Sync + 'static,\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "{\n";
|
|
code_writer->Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
// Generate the method
|
|
if (method->IsUserDefined()) {
|
|
string args = "";
|
|
for (const std::unique_ptr<AidlArgument>& arg : method->GetArguments()) {
|
|
if (!args.empty()) {
|
|
args += ", ";
|
|
}
|
|
args += kArgumentPrefix;
|
|
args += arg->GetName();
|
|
}
|
|
|
|
*code_writer << BuildMethod(*method, typenames) << " {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "self._rt.block_on(self._inner." << method->GetName() << "(" << args
|
|
<< "))\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
}
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
*code_writer << "let wrapped = Wrapper { _inner: inner, _rt: rt };\n";
|
|
*code_writer << "Self::new_binder(wrapped, features)\n";
|
|
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Emit the default trait
|
|
*code_writer << "pub trait " << default_trait_name << ": Send + Sync {\n";
|
|
code_writer->Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
if (!method->IsUserDefined()) {
|
|
continue;
|
|
}
|
|
|
|
// Generate the default method
|
|
*code_writer << BuildMethod(*method, typenames) << " {\n";
|
|
code_writer->Indent();
|
|
*code_writer << "Err(binder::StatusCode::UNKNOWN_TRANSACTION.into())\n";
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Generate the transaction code constants
|
|
// The constants get their own sub-module to avoid conflicts
|
|
*code_writer << "pub mod transactions {\n";
|
|
code_writer->Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
// Generate the transaction code constant
|
|
*code_writer << "pub const " << method->GetName()
|
|
<< ": binder::binder_impl::TransactionCode = "
|
|
"binder::binder_impl::FIRST_CALL_TRANSACTION + " +
|
|
std::to_string(method->GetId()) + ";\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Emit the default implementation code outside the trait
|
|
*code_writer << "pub type " << default_ref_name << " = Option<std::sync::Arc<dyn "
|
|
<< default_trait_name << ">>;\n";
|
|
*code_writer << "use lazy_static::lazy_static;\n";
|
|
*code_writer << "lazy_static! {\n";
|
|
*code_writer << " static ref DEFAULT_IMPL: std::sync::Mutex<" << default_ref_name
|
|
<< "> = std::sync::Mutex::new(None);\n";
|
|
*code_writer << "}\n";
|
|
|
|
// Emit the interface constants
|
|
GenerateConstantDeclarations(*code_writer, *iface, typenames);
|
|
|
|
// Emit VERSION and HASH
|
|
// These need to be top-level item constants instead of associated consts
|
|
// because the latter are incompatible with trait objects, see
|
|
// https://doc.rust-lang.org/reference/items/traits.html#object-safety
|
|
if (options.Version() > 0) {
|
|
*code_writer << "pub const VERSION: i32 = " << std::to_string(options.Version()) << ";\n";
|
|
}
|
|
if (!options.Hash().empty()) {
|
|
*code_writer << "pub const HASH: &str = \"" << options.Hash() << "\";\n";
|
|
}
|
|
|
|
// Generate the client-side method helpers
|
|
//
|
|
// The methods in this block are not marked pub, so they are not accessible from outside the
|
|
// AIDL generated code.
|
|
*code_writer << "impl " << client_name << " {\n";
|
|
code_writer->Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
GenerateClientMethodHelpers(*code_writer, *iface, *method, typenames, options, trait_name);
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Generate the client-side methods
|
|
*code_writer << "impl " << trait_name << " for " << client_name << " {\n";
|
|
code_writer->Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
GenerateClientMethod(*code_writer, *iface, *method, typenames, options, MethodKind::NORMAL);
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Generate the async client-side methods
|
|
*code_writer << "impl<P: binder::BinderAsyncPool> " << trait_name_async << "<P> for "
|
|
<< client_name << " {\n";
|
|
code_writer->Indent();
|
|
for (const auto& method : iface->GetMethods()) {
|
|
MethodKind kind = method->IsOneway() ? MethodKind::READY_FUTURE : MethodKind::BOXED_FUTURE;
|
|
GenerateClientMethod(*code_writer, *iface, *method, typenames, options, kind);
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
// Generate the server-side methods
|
|
GenerateServerItems(*code_writer, iface, typenames);
|
|
}
|
|
|
|
void GenerateParcelBody(CodeWriter& out, const AidlStructuredParcelable* parcel,
|
|
const AidlTypenames& typenames) {
|
|
GenerateDeprecated(out, *parcel);
|
|
out << "pub struct " << parcel->GetName() << " {\n";
|
|
out.Indent();
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
GenerateDeprecated(out, *variable);
|
|
auto field_type =
|
|
RustNameOf(variable->GetType(), typenames, StorageMode::PARCELABLE_FIELD, Lifetime::NONE);
|
|
out << "pub " << variable->GetName() << ": " << field_type << ",\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateParcelDefault(CodeWriter& out, const AidlStructuredParcelable* parcel) {
|
|
out << "impl Default for " << parcel->GetName() << " {\n";
|
|
out.Indent();
|
|
out << "fn default() -> Self {\n";
|
|
out.Indent();
|
|
out << "Self {\n";
|
|
out.Indent();
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
out << variable->GetName() << ": ";
|
|
if (variable->GetDefaultValue()) {
|
|
out << variable->ValueString(ConstantValueDecorator);
|
|
} else {
|
|
// Some types don't implement "Default".
|
|
// - ParcelableHolder
|
|
// - Arrays
|
|
if (variable->GetType().GetName() == "ParcelableHolder") {
|
|
out << "binder::ParcelableHolder::new(";
|
|
if (parcel->IsVintfStability()) {
|
|
out << "binder::binder_impl::Stability::Vintf";
|
|
} else {
|
|
out << "binder::binder_impl::Stability::Local";
|
|
}
|
|
out << ")";
|
|
} else if (variable->GetType().IsFixedSizeArray() && !variable->GetType().IsNullable()) {
|
|
out << ArrayDefaultValue(variable->GetType());
|
|
} else {
|
|
out << "Default::default()";
|
|
}
|
|
}
|
|
out << ",\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateParcelSerializeBody(CodeWriter& out, const AidlStructuredParcelable* parcel,
|
|
const AidlTypenames& typenames) {
|
|
out << "parcel.sized_write(|subparcel| {\n";
|
|
out.Indent();
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
if (TypeNeedsOption(variable->GetType(), typenames)) {
|
|
out << "let __field_ref = self." << variable->GetName()
|
|
<< ".as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?;\n";
|
|
out << "subparcel.write(__field_ref)?;\n";
|
|
} else {
|
|
out << "subparcel.write(&self." << variable->GetName() << ")?;\n";
|
|
}
|
|
}
|
|
out << "Ok(())\n";
|
|
out.Dedent();
|
|
out << "})\n";
|
|
}
|
|
|
|
void GenerateParcelDeserializeBody(CodeWriter& out, const AidlStructuredParcelable* parcel,
|
|
const AidlTypenames& typenames) {
|
|
out << "parcel.sized_read(|subparcel| {\n";
|
|
out.Indent();
|
|
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
out << "if subparcel.has_more_data() {\n";
|
|
out.Indent();
|
|
if (TypeNeedsOption(variable->GetType(), typenames)) {
|
|
out << "self." << variable->GetName() << " = Some(subparcel.read()?);\n";
|
|
} else {
|
|
out << "self." << variable->GetName() << " = subparcel.read()?;\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
out << "Ok(())\n";
|
|
out.Dedent();
|
|
out << "})\n";
|
|
}
|
|
|
|
void GenerateParcelBody(CodeWriter& out, const AidlUnionDecl* parcel,
|
|
const AidlTypenames& typenames) {
|
|
GenerateDeprecated(out, *parcel);
|
|
out << "pub enum " << parcel->GetName() << " {\n";
|
|
out.Indent();
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
GenerateDeprecated(out, *variable);
|
|
auto field_type =
|
|
RustNameOf(variable->GetType(), typenames, StorageMode::PARCELABLE_FIELD, Lifetime::NONE);
|
|
out << variable->GetCapitalizedName() << "(" << field_type << "),\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateParcelDefault(CodeWriter& out, const AidlUnionDecl* parcel) {
|
|
out << "impl Default for " << parcel->GetName() << " {\n";
|
|
out.Indent();
|
|
out << "fn default() -> Self {\n";
|
|
out.Indent();
|
|
|
|
AIDL_FATAL_IF(parcel->GetFields().empty(), *parcel)
|
|
<< "Union '" << parcel->GetName() << "' is empty.";
|
|
const auto& first_field = parcel->GetFields()[0];
|
|
const auto& first_value = first_field->ValueString(ConstantValueDecorator);
|
|
|
|
out << "Self::";
|
|
if (first_field->GetDefaultValue()) {
|
|
out << first_field->GetCapitalizedName() << "(" << first_value << ")\n";
|
|
} else {
|
|
out << first_field->GetCapitalizedName() << "(Default::default())\n";
|
|
}
|
|
|
|
out.Dedent();
|
|
out << "}\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateParcelSerializeBody(CodeWriter& out, const AidlUnionDecl* parcel,
|
|
const AidlTypenames& typenames) {
|
|
out << "match self {\n";
|
|
out.Indent();
|
|
int tag = 0;
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
out << "Self::" << variable->GetCapitalizedName() << "(v) => {\n";
|
|
out.Indent();
|
|
out << "parcel.write(&" << std::to_string(tag++) << "i32)?;\n";
|
|
if (TypeNeedsOption(variable->GetType(), typenames)) {
|
|
out << "let __field_ref = v.as_ref().ok_or(binder::StatusCode::UNEXPECTED_NULL)?;\n";
|
|
out << "parcel.write(__field_ref)\n";
|
|
} else {
|
|
out << "parcel.write(v)\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
void GenerateParcelDeserializeBody(CodeWriter& out, const AidlUnionDecl* parcel,
|
|
const AidlTypenames& typenames) {
|
|
out << "let tag: i32 = parcel.read()?;\n";
|
|
out << "match tag {\n";
|
|
out.Indent();
|
|
int tag = 0;
|
|
for (const auto& variable : parcel->GetFields()) {
|
|
auto field_type =
|
|
RustNameOf(variable->GetType(), typenames, StorageMode::PARCELABLE_FIELD, Lifetime::NONE);
|
|
|
|
out << std::to_string(tag++) << " => {\n";
|
|
out.Indent();
|
|
out << "let value: " << field_type << " = ";
|
|
if (TypeNeedsOption(variable->GetType(), typenames)) {
|
|
out << "Some(parcel.read()?);\n";
|
|
} else {
|
|
out << "parcel.read()?;\n";
|
|
}
|
|
out << "*self = Self::" << variable->GetCapitalizedName() << "(value);\n";
|
|
out << "Ok(())\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
out << "_ => {\n";
|
|
out << " Err(binder::StatusCode::BAD_VALUE)\n";
|
|
out << "}\n";
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
template <typename ParcelableType>
|
|
void GenerateParcelableTrait(CodeWriter& out, const ParcelableType* parcel,
|
|
const AidlTypenames& typenames) {
|
|
out << "impl binder::Parcelable for " << parcel->GetName() << " {\n";
|
|
out.Indent();
|
|
|
|
out << "fn write_to_parcel(&self, "
|
|
"parcel: &mut binder::binder_impl::BorrowedParcel) -> std::result::Result<(), "
|
|
"binder::StatusCode> "
|
|
"{\n";
|
|
out.Indent();
|
|
GenerateParcelSerializeBody(out, parcel, typenames);
|
|
out.Dedent();
|
|
out << "}\n";
|
|
|
|
out << "fn read_from_parcel(&mut self, "
|
|
"parcel: &binder::binder_impl::BorrowedParcel) -> std::result::Result<(), "
|
|
"binder::StatusCode> {\n";
|
|
out.Indent();
|
|
GenerateParcelDeserializeBody(out, parcel, typenames);
|
|
out.Dedent();
|
|
out << "}\n";
|
|
|
|
out.Dedent();
|
|
out << "}\n";
|
|
|
|
// Emit the outer (de)serialization traits
|
|
out << "binder::impl_serialize_for_parcelable!(" << parcel->GetName() << ");\n";
|
|
out << "binder::impl_deserialize_for_parcelable!(" << parcel->GetName() << ");\n";
|
|
}
|
|
|
|
template <typename ParcelableType>
|
|
void GenerateMetadataTrait(CodeWriter& out, const ParcelableType* parcel) {
|
|
out << "impl binder::binder_impl::ParcelableMetadata for " << parcel->GetName() << " {\n";
|
|
out.Indent();
|
|
|
|
out << "fn get_descriptor() -> &'static str { \"" << parcel->GetCanonicalName() << "\" }\n";
|
|
|
|
if (parcel->IsVintfStability()) {
|
|
out << "fn get_stability(&self) -> binder::binder_impl::Stability { "
|
|
"binder::binder_impl::Stability::Vintf }\n";
|
|
}
|
|
|
|
out.Dedent();
|
|
out << "}\n";
|
|
}
|
|
|
|
template <typename ParcelableType>
|
|
void GenerateRustParcel(CodeWriter* code_writer, const ParcelableType* parcel,
|
|
const AidlTypenames& typenames) {
|
|
// Debug is always derived because all Rust AIDL types implement it
|
|
// ParcelFileDescriptor doesn't support any of the others because
|
|
// it's a newtype over std::fs::File which only implements Debug
|
|
vector<string> derives{"Debug"};
|
|
const AidlAnnotation* derive_annotation = parcel->RustDerive();
|
|
if (derive_annotation != nullptr) {
|
|
for (const auto& name_and_param : derive_annotation->AnnotationParams(ConstantValueDecorator)) {
|
|
if (name_and_param.second == "true") {
|
|
derives.push_back(name_and_param.first);
|
|
}
|
|
}
|
|
}
|
|
|
|
*code_writer << "#[derive(" << Join(derives, ", ") << ")]\n";
|
|
GenerateParcelBody(*code_writer, parcel, typenames);
|
|
GenerateConstantDeclarations(*code_writer, *parcel, typenames);
|
|
GenerateParcelDefault(*code_writer, parcel);
|
|
GenerateParcelableTrait(*code_writer, parcel, typenames);
|
|
GenerateMetadataTrait(*code_writer, parcel);
|
|
}
|
|
|
|
void GenerateRustEnumDeclaration(CodeWriter* code_writer, const AidlEnumDeclaration* enum_decl,
|
|
const AidlTypenames& typenames) {
|
|
const auto& aidl_backing_type = enum_decl->GetBackingType();
|
|
auto backing_type = RustNameOf(aidl_backing_type, typenames, StorageMode::VALUE, Lifetime::NONE);
|
|
|
|
*code_writer << "#![allow(non_upper_case_globals)]\n";
|
|
*code_writer << "use binder::declare_binder_enum;\n";
|
|
*code_writer << "declare_binder_enum! {\n";
|
|
code_writer->Indent();
|
|
|
|
GenerateDeprecated(*code_writer, *enum_decl);
|
|
*code_writer << enum_decl->GetName() << " : [" << backing_type << "; "
|
|
<< std::to_string(enum_decl->GetEnumerators().size()) << "] {\n";
|
|
code_writer->Indent();
|
|
for (const auto& enumerator : enum_decl->GetEnumerators()) {
|
|
auto value = enumerator->GetValue()->ValueString(aidl_backing_type, ConstantValueDecorator);
|
|
GenerateDeprecated(*code_writer, *enumerator);
|
|
*code_writer << enumerator->GetName() << " = " << value << ",\n";
|
|
}
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
|
|
code_writer->Dedent();
|
|
*code_writer << "}\n";
|
|
}
|
|
|
|
void GenerateClass(CodeWriter* code_writer, const AidlDefinedType& defined_type,
|
|
const AidlTypenames& types, const Options& options) {
|
|
if (const AidlStructuredParcelable* parcelable = defined_type.AsStructuredParcelable();
|
|
parcelable != nullptr) {
|
|
GenerateRustParcel(code_writer, parcelable, types);
|
|
} else if (const AidlEnumDeclaration* enum_decl = defined_type.AsEnumDeclaration();
|
|
enum_decl != nullptr) {
|
|
GenerateRustEnumDeclaration(code_writer, enum_decl, types);
|
|
} else if (const AidlInterface* interface = defined_type.AsInterface(); interface != nullptr) {
|
|
GenerateRustInterface(code_writer, interface, types, options);
|
|
} else if (const AidlUnionDecl* union_decl = defined_type.AsUnionDeclaration();
|
|
union_decl != nullptr) {
|
|
GenerateRustParcel(code_writer, union_decl, types);
|
|
} else {
|
|
AIDL_FATAL(defined_type) << "Unrecognized type sent for Rust generation.";
|
|
}
|
|
|
|
for (const auto& nested : defined_type.GetNestedTypes()) {
|
|
(*code_writer) << "pub mod " << nested->GetName() << " {\n";
|
|
code_writer->Indent();
|
|
GenerateClass(code_writer, *nested, types, options);
|
|
code_writer->Dedent();
|
|
(*code_writer) << "}\n";
|
|
}
|
|
}
|
|
|
|
void GenerateRust(const string& filename, const Options& options, const AidlTypenames& types,
|
|
const AidlDefinedType& defined_type, const IoDelegate& io_delegate) {
|
|
CodeWriterPtr code_writer = io_delegate.GetCodeWriter(filename);
|
|
|
|
// Forbid the use of unsafe in auto-generated code.
|
|
// Unsafe code should only be allowed in libbinder_rs.
|
|
*code_writer << "#![forbid(unsafe_code)]\n";
|
|
// Disable rustfmt on auto-generated files, including the golden outputs
|
|
*code_writer << "#![rustfmt::skip]\n";
|
|
GenerateClass(code_writer.get(), defined_type, types, options);
|
|
GenerateMangledAliases(*code_writer, defined_type);
|
|
|
|
AIDL_FATAL_IF(!code_writer->Close(), defined_type) << "I/O Error!";
|
|
}
|
|
|
|
} // namespace rust
|
|
} // namespace aidl
|
|
} // namespace android
|