/*
|
* 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 "aidl.h"
|
#include "aidl_to_java.h"
|
#include "generate_java.h"
|
#include "options.h"
|
#include "type_java.h"
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
|
#include <algorithm>
|
#include <unordered_set>
|
#include <utility>
|
#include <vector>
|
|
#include <android-base/macros.h>
|
#include <android-base/stringprintf.h>
|
|
using android::base::Join;
|
using android::base::StringPrintf;
|
|
using std::string;
|
using std::unique_ptr;
|
using std::vector;
|
|
namespace android {
|
namespace aidl {
|
namespace java {
|
|
// =================================================
|
class VariableFactory {
|
public:
|
using Variable = ::android::aidl::java::Variable;
|
using Type = ::android::aidl::java::Type;
|
|
explicit VariableFactory(const std::string& base) : base_(base), index_(0) {}
|
Variable* Get(const Type* type) {
|
Variable* v = new Variable(type->JavaType(), StringPrintf("%s%d", base_.c_str(), index_));
|
vars_.push_back(v);
|
index_++;
|
return v;
|
}
|
|
Variable* Get(int index) { return vars_[index]; }
|
|
private:
|
std::vector<Variable*> vars_;
|
std::string base_;
|
int index_;
|
|
DISALLOW_COPY_AND_ASSIGN(VariableFactory);
|
};
|
|
// =================================================
|
class StubClass : public Class {
|
public:
|
StubClass(const Type* type, const InterfaceType* interfaceType, JavaTypeNamespace* types,
|
const Options& options);
|
~StubClass() override = default;
|
|
Variable* transact_code;
|
Variable* transact_data;
|
Variable* transact_reply;
|
Variable* transact_flags;
|
SwitchStatement* transact_switch;
|
StatementBlock* transact_statements;
|
SwitchStatement* code_to_method_name_switch;
|
|
// Where onTransact cases should be generated as separate methods.
|
bool transact_outline;
|
// Specific methods that should be outlined when transact_outline is true.
|
std::unordered_set<const AidlMethod*> outline_methods;
|
// Number of all methods.
|
size_t all_method_count;
|
|
// Finish generation. This will add a default case to the switch.
|
void finish();
|
|
Expression* get_transact_descriptor(const JavaTypeNamespace* types,
|
const AidlMethod* method);
|
|
private:
|
void make_as_interface(const InterfaceType* interfaceType,
|
JavaTypeNamespace* types);
|
|
Variable* transact_descriptor;
|
const Options& options_;
|
|
DISALLOW_COPY_AND_ASSIGN(StubClass);
|
};
|
|
StubClass::StubClass(const Type* type, const InterfaceType* interfaceType, JavaTypeNamespace* types,
|
const Options& options)
|
: Class(), options_(options) {
|
transact_descriptor = nullptr;
|
transact_outline = false;
|
all_method_count = 0; // Will be set when outlining may be enabled.
|
|
this->comment = "/** Local-side IPC implementation stub class. */";
|
this->modifiers = PUBLIC | ABSTRACT | STATIC;
|
this->what = Class::CLASS;
|
this->type = type->JavaType();
|
this->extends = types->BinderNativeType()->JavaType();
|
this->interfaces.push_back(interfaceType->JavaType());
|
|
// descriptor
|
Field* descriptor = new Field(STATIC | FINAL | PRIVATE,
|
new Variable(types->StringType()->JavaType(), "DESCRIPTOR"));
|
descriptor->value = "\"" + interfaceType->JavaType() + "\"";
|
this->elements.push_back(descriptor);
|
|
// ctor
|
Method* ctor = new Method;
|
ctor->modifiers = PUBLIC;
|
ctor->comment =
|
"/** Construct the stub at attach it to the "
|
"interface. */";
|
ctor->name = "Stub";
|
ctor->statements = new StatementBlock;
|
MethodCall* attach =
|
new MethodCall(THIS_VALUE, "attachInterface", 2, THIS_VALUE,
|
new LiteralExpression("DESCRIPTOR"));
|
ctor->statements->Add(attach);
|
this->elements.push_back(ctor);
|
|
// asInterface
|
make_as_interface(interfaceType, types);
|
|
// asBinder
|
Method* asBinder = new Method;
|
asBinder->modifiers = PUBLIC | OVERRIDE;
|
asBinder->returnType = types->IBinderType()->JavaType();
|
asBinder->name = "asBinder";
|
asBinder->statements = new StatementBlock;
|
asBinder->statements->Add(new ReturnStatement(THIS_VALUE));
|
this->elements.push_back(asBinder);
|
|
if (options_.GenTransactionNames()) {
|
// getDefaultTransactionName
|
Method* getDefaultTransactionName = new Method;
|
getDefaultTransactionName->comment = "/** @hide */";
|
getDefaultTransactionName->modifiers = PUBLIC | STATIC;
|
getDefaultTransactionName->returnType = types->StringType()->JavaType();
|
getDefaultTransactionName->name = "getDefaultTransactionName";
|
Variable* code = new Variable(types->IntType()->JavaType(), "transactionCode");
|
getDefaultTransactionName->parameters.push_back(code);
|
getDefaultTransactionName->statements = new StatementBlock;
|
this->code_to_method_name_switch = new SwitchStatement(code);
|
getDefaultTransactionName->statements->Add(this->code_to_method_name_switch);
|
this->elements.push_back(getDefaultTransactionName);
|
|
// getTransactionName
|
Method* getTransactionName = new Method;
|
getTransactionName->comment = "/** @hide */";
|
getTransactionName->modifiers = PUBLIC;
|
getTransactionName->returnType = types->StringType()->JavaType();
|
getTransactionName->name = "getTransactionName";
|
Variable* code2 = new Variable(types->IntType()->JavaType(), "transactionCode");
|
getTransactionName->parameters.push_back(code2);
|
getTransactionName->statements = new StatementBlock;
|
getTransactionName->statements->Add(
|
new ReturnStatement(new MethodCall(THIS_VALUE, "getDefaultTransactionName", 1, code2)));
|
this->elements.push_back(getTransactionName);
|
}
|
|
// onTransact
|
this->transact_code = new Variable(types->IntType()->JavaType(), "code");
|
this->transact_data = new Variable(types->ParcelType()->JavaType(), "data");
|
this->transact_reply = new Variable(types->ParcelType()->JavaType(), "reply");
|
this->transact_flags = new Variable(types->IntType()->JavaType(), "flags");
|
Method* onTransact = new Method;
|
onTransact->modifiers = PUBLIC | OVERRIDE;
|
onTransact->returnType = types->BoolType()->JavaType();
|
onTransact->name = "onTransact";
|
onTransact->parameters.push_back(this->transact_code);
|
onTransact->parameters.push_back(this->transact_data);
|
onTransact->parameters.push_back(this->transact_reply);
|
onTransact->parameters.push_back(this->transact_flags);
|
onTransact->statements = new StatementBlock;
|
transact_statements = onTransact->statements;
|
onTransact->exceptions.push_back(types->RemoteExceptionType()->JavaType());
|
this->elements.push_back(onTransact);
|
this->transact_switch = new SwitchStatement(this->transact_code);
|
}
|
|
void StubClass::finish() {
|
Case* default_case = new Case;
|
|
MethodCall* superCall = new MethodCall(
|
SUPER_VALUE, "onTransact", 4, this->transact_code, this->transact_data,
|
this->transact_reply, this->transact_flags);
|
default_case->statements->Add(new ReturnStatement(superCall));
|
transact_switch->cases.push_back(default_case);
|
|
transact_statements->Add(this->transact_switch);
|
|
// getTransactionName
|
if (options_.GenTransactionNames()) {
|
// Some transaction codes are common, e.g. INTERFACE_TRANSACTION or DUMP_TRANSACTION.
|
// Common transaction codes will not be resolved to a string by getTransactionName. The method
|
// will return NULL in this case.
|
Case* code_switch_default_case = new Case;
|
code_switch_default_case->statements->Add(new ReturnStatement(NULL_VALUE));
|
this->code_to_method_name_switch->cases.push_back(code_switch_default_case);
|
}
|
}
|
|
// The the expression for the interface's descriptor to be used when
|
// generating code for the given method. Null is acceptable for method
|
// and stands for synthetic cases.
|
Expression* StubClass::get_transact_descriptor(const JavaTypeNamespace* types,
|
const AidlMethod* method) {
|
if (transact_outline) {
|
if (method != nullptr) {
|
// When outlining, each outlined method needs its own literal.
|
if (outline_methods.count(method) != 0) {
|
return new LiteralExpression("DESCRIPTOR");
|
}
|
} else {
|
// Synthetic case. A small number is assumed. Use its own descriptor
|
// if there are only synthetic cases.
|
if (outline_methods.size() == all_method_count) {
|
return new LiteralExpression("DESCRIPTOR");
|
}
|
}
|
}
|
|
// When not outlining, store the descriptor literal into a local variable, in
|
// an effort to save const-string instructions in each switch case.
|
if (transact_descriptor == nullptr) {
|
transact_descriptor = new Variable(types->StringType()->JavaType(), "descriptor");
|
transact_statements->Add(
|
new VariableDeclaration(transact_descriptor,
|
new LiteralExpression("DESCRIPTOR")));
|
}
|
return transact_descriptor;
|
}
|
|
void StubClass::make_as_interface(const InterfaceType* interfaceType,
|
JavaTypeNamespace* types) {
|
Variable* obj = new Variable(types->IBinderType()->JavaType(), "obj");
|
|
Method* m = new Method;
|
m->comment = "/**\n * Cast an IBinder object into an ";
|
m->comment += interfaceType->JavaType();
|
m->comment += " interface,\n";
|
m->comment += " * generating a proxy if needed.\n */";
|
m->modifiers = PUBLIC | STATIC;
|
m->returnType = interfaceType->JavaType();
|
m->name = "asInterface";
|
m->parameters.push_back(obj);
|
m->statements = new StatementBlock;
|
|
IfStatement* ifstatement = new IfStatement();
|
ifstatement->expression = new Comparison(obj, "==", NULL_VALUE);
|
ifstatement->statements = new StatementBlock;
|
ifstatement->statements->Add(new ReturnStatement(NULL_VALUE));
|
m->statements->Add(ifstatement);
|
|
// IInterface iin = obj.queryLocalInterface(DESCRIPTOR)
|
MethodCall* queryLocalInterface = new MethodCall(obj, "queryLocalInterface");
|
queryLocalInterface->arguments.push_back(new LiteralExpression("DESCRIPTOR"));
|
IInterfaceType iinType(types);
|
Variable* iin = new Variable(iinType.JavaType(), "iin");
|
VariableDeclaration* iinVd = new VariableDeclaration(iin, queryLocalInterface);
|
m->statements->Add(iinVd);
|
|
// Ensure the instance type of the local object is as expected.
|
// One scenario where this is needed is if another package (with a
|
// different class loader) runs in the same process as the service.
|
|
// if (iin != null && iin instanceof <interfaceType>) return (<interfaceType>)
|
// iin;
|
Comparison* iinNotNull = new Comparison(iin, "!=", NULL_VALUE);
|
Comparison* instOfCheck =
|
new Comparison(iin, " instanceof ",
|
new LiteralExpression(interfaceType->JavaType()));
|
IfStatement* instOfStatement = new IfStatement();
|
instOfStatement->expression = new Comparison(iinNotNull, "&&", instOfCheck);
|
instOfStatement->statements = new StatementBlock;
|
instOfStatement->statements->Add(new ReturnStatement(new Cast(interfaceType->JavaType(), iin)));
|
m->statements->Add(instOfStatement);
|
|
NewExpression* ne = new NewExpression(interfaceType->GetProxy()->InstantiableName());
|
ne->arguments.push_back(obj);
|
m->statements->Add(new ReturnStatement(ne));
|
|
this->elements.push_back(m);
|
}
|
|
// =================================================
|
class ProxyClass : public Class {
|
public:
|
ProxyClass(const JavaTypeNamespace* types, const Type* type, const InterfaceType* interfaceType,
|
const Options& options);
|
~ProxyClass() override;
|
|
Variable* mRemote;
|
};
|
|
ProxyClass::ProxyClass(const JavaTypeNamespace* types, const Type* type,
|
const InterfaceType* interfaceType, const Options& options)
|
: Class() {
|
this->modifiers = PRIVATE | STATIC;
|
this->what = Class::CLASS;
|
this->type = type->JavaType();
|
this->interfaces.push_back(interfaceType->JavaType());
|
|
// IBinder mRemote
|
mRemote = new Variable(types->IBinderType()->JavaType(), "mRemote");
|
this->elements.push_back(new Field(PRIVATE, mRemote));
|
|
// Proxy()
|
Variable* remote = new Variable(types->IBinderType()->JavaType(), "remote");
|
Method* ctor = new Method;
|
ctor->name = "Proxy";
|
ctor->statements = new StatementBlock;
|
ctor->parameters.push_back(remote);
|
ctor->statements->Add(new Assignment(mRemote, remote));
|
this->elements.push_back(ctor);
|
|
if (options.Version() > 0) {
|
std::ostringstream code;
|
code << "private int mCachedVersion = -1;\n";
|
this->elements.emplace_back(new LiteralClassElement(code.str()));
|
}
|
|
// IBinder asBinder()
|
Method* asBinder = new Method;
|
asBinder->modifiers = PUBLIC | OVERRIDE;
|
asBinder->returnType = types->IBinderType()->JavaType();
|
asBinder->name = "asBinder";
|
asBinder->statements = new StatementBlock;
|
asBinder->statements->Add(new ReturnStatement(mRemote));
|
this->elements.push_back(asBinder);
|
}
|
|
ProxyClass::~ProxyClass() {}
|
|
// =================================================
|
static void generate_new_array(const Type* t, StatementBlock* addTo,
|
Variable* v, Variable* parcel,
|
JavaTypeNamespace* types) {
|
Variable* len = new Variable(types->IntType()->JavaType(), v->name + "_length");
|
addTo->Add(new VariableDeclaration(len, new MethodCall(parcel, "readInt")));
|
IfStatement* lencheck = new IfStatement();
|
lencheck->expression = new Comparison(len, "<", new LiteralExpression("0"));
|
lencheck->statements->Add(new Assignment(v, NULL_VALUE));
|
lencheck->elseif = new IfStatement();
|
lencheck->elseif->statements->Add(new Assignment(v, new NewArrayExpression(t->JavaType(), len)));
|
addTo->Add(lencheck);
|
}
|
|
static void generate_write_to_parcel(const AidlTypeSpecifier& type, StatementBlock* addTo,
|
Variable* v, Variable* parcel, bool is_return_value,
|
const AidlTypenames& typenames) {
|
string code;
|
CodeWriterPtr writer = CodeWriter::ForString(&code);
|
CodeGeneratorContext context{
|
.writer = *(writer.get()),
|
.typenames = typenames,
|
.type = type,
|
.var = v->name,
|
.parcel = parcel->name,
|
.is_return_value = is_return_value,
|
};
|
WriteToParcelFor(context);
|
writer->Close();
|
addTo->Add(new LiteralStatement(code));
|
}
|
|
static void generate_int_constant(Class* interface, const std::string& name,
|
const std::string& value) {
|
auto code = StringPrintf("public static final int %s = %s;\n", name.c_str(), value.c_str());
|
interface->elements.push_back(new LiteralClassElement(code));
|
}
|
|
static void generate_string_constant(Class* interface, const std::string& name,
|
const std::string& value) {
|
auto code = StringPrintf("public static final String %s = %s;\n", name.c_str(), value.c_str());
|
interface->elements.push_back(new LiteralClassElement(code));
|
}
|
|
static std::unique_ptr<Method> generate_interface_method(
|
const AidlMethod& method, JavaTypeNamespace* types) {
|
std::unique_ptr<Method> decl(new Method);
|
decl->comment = method.GetComments();
|
decl->modifiers = PUBLIC;
|
decl->returnType = method.GetType().GetLanguageType<Type>()->JavaType();
|
decl->returnTypeDimension = method.GetType().IsArray() ? 1 : 0;
|
decl->name = method.GetName();
|
decl->annotations = generate_java_annotations(method.GetType());
|
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
decl->parameters.push_back(new Variable(arg->GetType().GetLanguageType<Type>()->JavaType(),
|
arg->GetName(), arg->GetType().IsArray() ? 1 : 0));
|
}
|
|
decl->exceptions.push_back(types->RemoteExceptionType()->JavaType());
|
|
return decl;
|
}
|
|
static void generate_stub_code(const AidlInterface& iface, const AidlMethod& method, bool oneway,
|
Variable* transact_data, Variable* transact_reply,
|
JavaTypeNamespace* types, StatementBlock* statements,
|
StubClass* stubClass, const Options& options) {
|
TryStatement* tryStatement = nullptr;
|
FinallyStatement* finallyStatement = nullptr;
|
MethodCall* realCall = new MethodCall(THIS_VALUE, method.GetName());
|
|
// interface token validation is the very first thing we do
|
statements->Add(new MethodCall(transact_data,
|
"enforceInterface", 1,
|
stubClass->get_transact_descriptor(types,
|
&method)));
|
|
// args
|
VariableFactory stubArgs("_arg");
|
{
|
// keep this across different args in order to create the classloader
|
// at most once.
|
bool is_classloader_created = false;
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
const Type* t = arg->GetType().GetLanguageType<Type>();
|
Variable* v = stubArgs.Get(t);
|
v->dimension = arg->GetType().IsArray() ? 1 : 0;
|
|
statements->Add(new VariableDeclaration(v));
|
|
if (arg->GetDirection() & AidlArgument::IN_DIR) {
|
string code;
|
CodeWriterPtr writer = CodeWriter::ForString(&code);
|
CodeGeneratorContext context{.writer = *(writer.get()),
|
.typenames = types->typenames_,
|
.type = arg->GetType(),
|
.var = v->name,
|
.parcel = transact_data->name,
|
.is_classloader_created = &is_classloader_created};
|
CreateFromParcelFor(context);
|
writer->Close();
|
statements->Add(new LiteralStatement(code));
|
} else {
|
if (!arg->GetType().IsArray()) {
|
statements->Add(new Assignment(v, new NewExpression(t->InstantiableName())));
|
} else {
|
generate_new_array(t, statements, v, transact_data, types);
|
}
|
}
|
|
realCall->arguments.push_back(v);
|
}
|
}
|
|
if (options.GenTraces()) {
|
// try and finally, but only when generating trace code
|
tryStatement = new TryStatement();
|
finallyStatement = new FinallyStatement();
|
|
tryStatement->statements->Add(new MethodCall(
|
new LiteralExpression("android.os.Trace"), "traceBegin", 2,
|
new LiteralExpression("android.os.Trace.TRACE_TAG_AIDL"),
|
new StringLiteralExpression(iface.GetName() + "::"
|
+ method.GetName() + "::server")));
|
|
finallyStatement->statements->Add(new MethodCall(
|
new LiteralExpression("android.os.Trace"), "traceEnd", 1,
|
new LiteralExpression("android.os.Trace.TRACE_TAG_AIDL")));
|
}
|
|
// the real call
|
if (method.GetType().GetName() == "void") {
|
if (options.GenTraces()) {
|
statements->Add(tryStatement);
|
tryStatement->statements->Add(realCall);
|
statements->Add(finallyStatement);
|
} else {
|
statements->Add(realCall);
|
}
|
|
if (!oneway) {
|
// report that there were no exceptions
|
MethodCall* ex =
|
new MethodCall(transact_reply, "writeNoException", 0);
|
statements->Add(ex);
|
}
|
} else {
|
Variable* _result = new Variable(method.GetType().GetLanguageType<Type>()->JavaType(),
|
"_result", method.GetType().IsArray() ? 1 : 0);
|
if (options.GenTraces()) {
|
statements->Add(new VariableDeclaration(_result));
|
statements->Add(tryStatement);
|
tryStatement->statements->Add(new Assignment(_result, realCall));
|
statements->Add(finallyStatement);
|
} else {
|
statements->Add(new VariableDeclaration(_result, realCall));
|
}
|
|
if (!oneway) {
|
// report that there were no exceptions
|
MethodCall* ex =
|
new MethodCall(transact_reply, "writeNoException", 0);
|
statements->Add(ex);
|
}
|
|
// marshall the return value
|
generate_write_to_parcel(method.GetType(), statements, _result, transact_reply, true,
|
types->typenames_);
|
}
|
|
// out parameters
|
int i = 0;
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
Variable* v = stubArgs.Get(i++);
|
|
if (arg->GetDirection() & AidlArgument::OUT_DIR) {
|
generate_write_to_parcel(arg->GetType(), statements, v, transact_reply, true,
|
types->typenames_);
|
}
|
}
|
|
// return true
|
statements->Add(new ReturnStatement(TRUE_VALUE));
|
}
|
|
static void generate_stub_case(const AidlInterface& iface, const AidlMethod& method,
|
const std::string& transactCodeName, bool oneway,
|
StubClass* stubClass, JavaTypeNamespace* types,
|
const Options& options) {
|
Case* c = new Case(transactCodeName);
|
|
generate_stub_code(iface, method, oneway, stubClass->transact_data, stubClass->transact_reply,
|
types, c->statements, stubClass, options);
|
|
stubClass->transact_switch->cases.push_back(c);
|
}
|
|
static void generate_stub_case_outline(const AidlInterface& iface, const AidlMethod& method,
|
const std::string& transactCodeName, bool oneway,
|
StubClass* stubClass, JavaTypeNamespace* types,
|
const Options& options) {
|
std::string outline_name = "onTransact$" + method.GetName() + "$";
|
// Generate an "outlined" method with the actual code.
|
{
|
Variable* transact_data = new Variable(types->ParcelType()->JavaType(), "data");
|
Variable* transact_reply = new Variable(types->ParcelType()->JavaType(), "reply");
|
Method* onTransact_case = new Method;
|
onTransact_case->modifiers = PRIVATE;
|
onTransact_case->returnType = types->BoolType()->JavaType();
|
onTransact_case->name = outline_name;
|
onTransact_case->parameters.push_back(transact_data);
|
onTransact_case->parameters.push_back(transact_reply);
|
onTransact_case->statements = new StatementBlock;
|
onTransact_case->exceptions.push_back(types->RemoteExceptionType()->JavaType());
|
stubClass->elements.push_back(onTransact_case);
|
|
generate_stub_code(iface, method, oneway, transact_data, transact_reply, types,
|
onTransact_case->statements, stubClass, options);
|
}
|
|
// Generate the case dispatch.
|
{
|
Case* c = new Case(transactCodeName);
|
|
MethodCall* helper_call = new MethodCall(THIS_VALUE,
|
outline_name,
|
2,
|
stubClass->transact_data,
|
stubClass->transact_reply);
|
c->statements->Add(new ReturnStatement(helper_call));
|
|
stubClass->transact_switch->cases.push_back(c);
|
}
|
}
|
|
static std::unique_ptr<Method> generate_proxy_method(
|
const AidlInterface& iface, const AidlMethod& method, const std::string& transactCodeName,
|
bool oneway, ProxyClass* proxyClass, JavaTypeNamespace* types, const Options& options) {
|
std::unique_ptr<Method> proxy(new Method);
|
proxy->comment = method.GetComments();
|
proxy->modifiers = PUBLIC | OVERRIDE;
|
proxy->returnType = method.GetType().GetLanguageType<Type>()->JavaType();
|
proxy->returnTypeDimension = method.GetType().IsArray() ? 1 : 0;
|
proxy->name = method.GetName();
|
proxy->statements = new StatementBlock;
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
proxy->parameters.push_back(new Variable(arg->GetType().GetLanguageType<Type>()->JavaType(),
|
arg->GetName(), arg->GetType().IsArray() ? 1 : 0));
|
}
|
proxy->exceptions.push_back(types->RemoteExceptionType()->JavaType());
|
|
// the parcels
|
Variable* _data = new Variable(types->ParcelType()->JavaType(), "_data");
|
proxy->statements->Add(
|
new VariableDeclaration(_data, new MethodCall(types->ParcelType()->JavaType(), "obtain")));
|
Variable* _reply = nullptr;
|
if (!oneway) {
|
_reply = new Variable(types->ParcelType()->JavaType(), "_reply");
|
proxy->statements->Add(
|
new VariableDeclaration(_reply, new MethodCall(types->ParcelType()->JavaType(), "obtain")));
|
}
|
|
// the return value
|
Variable* _result = nullptr;
|
if (method.GetType().GetName() != "void") {
|
_result = new Variable(*proxy->returnType, "_result", method.GetType().IsArray() ? 1 : 0);
|
proxy->statements->Add(new VariableDeclaration(_result));
|
}
|
|
// try and finally
|
TryStatement* tryStatement = new TryStatement();
|
proxy->statements->Add(tryStatement);
|
FinallyStatement* finallyStatement = new FinallyStatement();
|
proxy->statements->Add(finallyStatement);
|
|
if (options.GenTraces()) {
|
tryStatement->statements->Add(new MethodCall(
|
new LiteralExpression("android.os.Trace"), "traceBegin", 2,
|
new LiteralExpression("android.os.Trace.TRACE_TAG_AIDL"),
|
new StringLiteralExpression(iface.GetName() + "::" +
|
method.GetName() + "::client")));
|
}
|
|
// the interface identifier token: the DESCRIPTOR constant, marshalled as a
|
// string
|
tryStatement->statements->Add(new MethodCall(
|
_data, "writeInterfaceToken", 1, new LiteralExpression("DESCRIPTOR")));
|
|
// the parameters
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
const Type* t = arg->GetType().GetLanguageType<Type>();
|
Variable* v = new Variable(t->JavaType(), arg->GetName(), arg->GetType().IsArray() ? 1 : 0);
|
AidlArgument::Direction dir = arg->GetDirection();
|
if (dir == AidlArgument::OUT_DIR && arg->GetType().IsArray()) {
|
IfStatement* checklen = new IfStatement();
|
checklen->expression = new Comparison(v, "==", NULL_VALUE);
|
checklen->statements->Add(
|
new MethodCall(_data, "writeInt", 1, new LiteralExpression("-1")));
|
checklen->elseif = new IfStatement();
|
checklen->elseif->statements->Add(
|
new MethodCall(_data, "writeInt", 1, new FieldVariable(v, "length")));
|
tryStatement->statements->Add(checklen);
|
} else if (dir & AidlArgument::IN_DIR) {
|
generate_write_to_parcel(arg->GetType(), tryStatement->statements, v, _data, false,
|
types->typenames_);
|
} else {
|
delete v;
|
}
|
}
|
|
// the transact call
|
unique_ptr<MethodCall> call(new MethodCall(
|
proxyClass->mRemote, "transact", 4, new LiteralExpression("Stub." + transactCodeName), _data,
|
_reply ? _reply : NULL_VALUE,
|
new LiteralExpression(oneway ? "android.os.IBinder.FLAG_ONEWAY" : "0")));
|
unique_ptr<Variable> _status(new Variable(types->BoolType()->JavaType(), "_status"));
|
tryStatement->statements->Add(new VariableDeclaration(_status.release(), call.release()));
|
|
// If the transaction returns false, which means UNKNOWN_TRANSACTION, fall
|
// back to the local method in the default impl, if set before.
|
vector<string> arg_names;
|
for (const auto& arg : method.GetArguments()) {
|
arg_names.emplace_back(arg->GetName());
|
}
|
bool has_return_type = method.GetType().GetName() != "void";
|
tryStatement->statements->Add(new LiteralStatement(
|
android::base::StringPrintf(has_return_type ? "if (!_status && getDefaultImpl() != null) {\n"
|
" return getDefaultImpl().%s(%s);\n"
|
"}\n"
|
: "if (!_status && getDefaultImpl() != null) {\n"
|
" getDefaultImpl().%s(%s);\n"
|
" return;\n"
|
"}\n",
|
method.GetName().c_str(), Join(arg_names, ", ").c_str())));
|
|
// throw back exceptions.
|
if (_reply) {
|
MethodCall* ex = new MethodCall(_reply, "readException", 0);
|
tryStatement->statements->Add(ex);
|
}
|
|
// returning and cleanup
|
if (_reply != nullptr) {
|
// keep this across return value and arguments in order to create the
|
// classloader at most once.
|
bool is_classloader_created = false;
|
if (_result != nullptr) {
|
string code;
|
CodeWriterPtr writer = CodeWriter::ForString(&code);
|
CodeGeneratorContext context{.writer = *(writer.get()),
|
.typenames = types->typenames_,
|
.type = method.GetType(),
|
.var = _result->name,
|
.parcel = _reply->name,
|
.is_classloader_created = &is_classloader_created};
|
CreateFromParcelFor(context);
|
writer->Close();
|
tryStatement->statements->Add(new LiteralStatement(code));
|
}
|
|
// the out/inout parameters
|
for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
|
if (arg->GetDirection() & AidlArgument::OUT_DIR) {
|
string code;
|
CodeWriterPtr writer = CodeWriter::ForString(&code);
|
CodeGeneratorContext context{.writer = *(writer.get()),
|
.typenames = types->typenames_,
|
.type = arg->GetType(),
|
.var = arg->GetName(),
|
.parcel = _reply->name,
|
.is_classloader_created = &is_classloader_created};
|
ReadFromParcelFor(context);
|
writer->Close();
|
tryStatement->statements->Add(new LiteralStatement(code));
|
}
|
}
|
|
finallyStatement->statements->Add(new MethodCall(_reply, "recycle"));
|
}
|
finallyStatement->statements->Add(new MethodCall(_data, "recycle"));
|
|
if (options.GenTraces()) {
|
finallyStatement->statements->Add(new MethodCall(
|
new LiteralExpression("android.os.Trace"), "traceEnd", 1,
|
new LiteralExpression("android.os.Trace.TRACE_TAG_AIDL")));
|
}
|
|
if (_result != nullptr) {
|
proxy->statements->Add(new ReturnStatement(_result));
|
}
|
|
return proxy;
|
}
|
|
static void generate_methods(const AidlInterface& iface, const AidlMethod& method, Class* interface,
|
StubClass* stubClass, ProxyClass* proxyClass, int index,
|
JavaTypeNamespace* types, const Options& options) {
|
const bool oneway = method.IsOneway();
|
|
// == the TRANSACT_ constant =============================================
|
string transactCodeName = "TRANSACTION_";
|
transactCodeName += method.GetName();
|
|
Field* transactCode =
|
new Field(STATIC | FINAL, new Variable(types->IntType()->JavaType(), transactCodeName));
|
transactCode->value =
|
StringPrintf("(android.os.IBinder.FIRST_CALL_TRANSACTION + %d)", index);
|
stubClass->elements.push_back(transactCode);
|
|
// getTransactionName
|
if (options.GenTransactionNames()) {
|
Case* c = new Case(transactCodeName);
|
c->statements->Add(new ReturnStatement(new StringLiteralExpression(method.GetName())));
|
stubClass->code_to_method_name_switch->cases.push_back(c);
|
}
|
|
// == the declaration in the interface ===================================
|
ClassElement* decl;
|
if (method.IsUserDefined()) {
|
decl = generate_interface_method(method, types).release();
|
} else {
|
if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
std::ostringstream code;
|
code << "public int " << kGetInterfaceVersion << "() "
|
<< "throws android.os.RemoteException;\n";
|
decl = new LiteralClassElement(code.str());
|
}
|
}
|
interface->elements.push_back(decl);
|
|
// == the stub method ====================================================
|
if (method.IsUserDefined()) {
|
bool outline_stub =
|
stubClass->transact_outline && stubClass->outline_methods.count(&method) != 0;
|
if (outline_stub) {
|
generate_stub_case_outline(iface, method, transactCodeName, oneway, stubClass, types,
|
options);
|
} else {
|
generate_stub_case(iface, method, transactCodeName, oneway, stubClass, types, options);
|
}
|
} else {
|
if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
Case* c = new Case(transactCodeName);
|
std::ostringstream code;
|
code << "data.enforceInterface(descriptor);\n"
|
<< "reply.writeNoException();\n"
|
<< "reply.writeInt(" << kGetInterfaceVersion << "());\n"
|
<< "return true;\n";
|
c->statements->Add(new LiteralStatement(code.str()));
|
stubClass->transact_switch->cases.push_back(c);
|
}
|
}
|
|
// == the proxy method ===================================================
|
ClassElement* proxy = nullptr;
|
if (method.IsUserDefined()) {
|
proxy =
|
generate_proxy_method(iface, method, transactCodeName, oneway, proxyClass, types, options)
|
.release();
|
|
} else {
|
if (method.GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
std::ostringstream code;
|
code << "@Override\n"
|
<< "public int " << kGetInterfaceVersion << "()"
|
<< " throws "
|
<< "android.os.RemoteException {\n"
|
<< " if (mCachedVersion == -1) {\n"
|
<< " android.os.Parcel data = android.os.Parcel.obtain();\n"
|
<< " android.os.Parcel reply = android.os.Parcel.obtain();\n"
|
<< " try {\n"
|
<< " data.writeInterfaceToken(DESCRIPTOR);\n"
|
<< " mRemote.transact(Stub." << transactCodeName << ", "
|
<< "data, reply, 0);\n"
|
<< " reply.readException();\n"
|
<< " mCachedVersion = reply.readInt();\n"
|
<< " } finally {\n"
|
<< " reply.recycle();\n"
|
<< " data.recycle();\n"
|
<< " }\n"
|
<< " }\n"
|
<< " return mCachedVersion;\n"
|
<< "}\n";
|
proxy = new LiteralClassElement(code.str());
|
}
|
}
|
if (proxy != nullptr) {
|
proxyClass->elements.push_back(proxy);
|
}
|
}
|
|
static void generate_interface_descriptors(StubClass* stub, ProxyClass* proxy,
|
const JavaTypeNamespace* types) {
|
// the interface descriptor transaction handler
|
Case* c = new Case("INTERFACE_TRANSACTION");
|
c->statements->Add(new MethodCall(stub->transact_reply, "writeString", 1,
|
stub->get_transact_descriptor(types,
|
nullptr)));
|
c->statements->Add(new ReturnStatement(TRUE_VALUE));
|
stub->transact_switch->cases.push_back(c);
|
|
// and the proxy-side method returning the descriptor directly
|
Method* getDesc = new Method;
|
getDesc->modifiers = PUBLIC;
|
getDesc->returnType = types->StringType()->JavaType();
|
getDesc->returnTypeDimension = 0;
|
getDesc->name = "getInterfaceDescriptor";
|
getDesc->statements = new StatementBlock;
|
getDesc->statements->Add(
|
new ReturnStatement(new LiteralExpression("DESCRIPTOR")));
|
proxy->elements.push_back(getDesc);
|
}
|
|
// Check whether (some) methods in this interface should be "outlined," that
|
// is, have specific onTransact methods for certain cases. Set up StubClass
|
// metadata accordingly.
|
//
|
// Outlining will be enabled if the interface has more than outline_threshold
|
// methods. In that case, the methods are sorted by number of arguments
|
// (so that more "complex" methods come later), and the first non_outline_count
|
// number of methods not outlined (are kept in the onTransact() method).
|
//
|
// Requirements: non_outline_count <= outline_threshold.
|
static void compute_outline_methods(const AidlInterface* iface,
|
StubClass* stub,
|
size_t outline_threshold,
|
size_t non_outline_count) {
|
CHECK_LE(non_outline_count, outline_threshold);
|
// We'll outline (create sub methods) if there are more than min_methods
|
// cases.
|
stub->transact_outline = iface->GetMethods().size() > outline_threshold;
|
if (stub->transact_outline) {
|
stub->all_method_count = iface->GetMethods().size();
|
std::vector<const AidlMethod*> methods;
|
methods.reserve(iface->GetMethods().size());
|
for (const std::unique_ptr<AidlMethod>& ptr : iface->GetMethods()) {
|
methods.push_back(ptr.get());
|
}
|
|
std::stable_sort(
|
methods.begin(),
|
methods.end(),
|
[](const AidlMethod* m1, const AidlMethod* m2) {
|
return m1->GetArguments().size() < m2->GetArguments().size();
|
});
|
|
stub->outline_methods.insert(methods.begin() + non_outline_count,
|
methods.end());
|
}
|
}
|
|
static unique_ptr<ClassElement> generate_default_impl_method(const AidlMethod& method) {
|
unique_ptr<Method> default_method(new Method);
|
default_method->comment = method.GetComments();
|
default_method->modifiers = PUBLIC | OVERRIDE;
|
default_method->returnType = method.GetType().GetLanguageType<Type>()->JavaType();
|
default_method->returnTypeDimension = method.GetType().IsArray() ? 1 : 0;
|
default_method->name = method.GetName();
|
default_method->statements = new StatementBlock;
|
for (const auto& arg : method.GetArguments()) {
|
default_method->parameters.push_back(
|
new Variable(arg->GetType().GetLanguageType<Type>()->JavaType(), arg->GetName(),
|
arg->GetType().IsArray() ? 1 : 0));
|
}
|
default_method->exceptions.push_back(method.GetType()
|
.GetLanguageType<Type>()
|
->GetTypeNamespace()
|
->RemoteExceptionType()
|
->JavaType());
|
|
if (method.GetType().GetName() != "void") {
|
const string& defaultValue = DefaultJavaValueOf(method.GetType());
|
default_method->statements->Add(
|
new LiteralStatement(StringPrintf("return %s;\n", defaultValue.c_str())));
|
}
|
return default_method;
|
}
|
|
static unique_ptr<Class> generate_default_impl_class(const AidlInterface& iface,
|
const Options& options) {
|
unique_ptr<Class> default_class(new Class);
|
default_class->comment = "/** Default implementation for " + iface.GetName() + ". */";
|
default_class->modifiers = PUBLIC | STATIC;
|
default_class->what = Class::CLASS;
|
default_class->type = iface.GetLanguageType<InterfaceType>()->GetDefaultImpl()->JavaType();
|
default_class->interfaces.emplace_back(iface.GetLanguageType<InterfaceType>()->JavaType());
|
|
for (const auto& m : iface.GetMethods()) {
|
if (m->IsUserDefined()) {
|
default_class->elements.emplace_back(generate_default_impl_method(*(m.get())).release());
|
} else {
|
if (m->GetName() == kGetInterfaceVersion && options.Version() > 0) {
|
// This is called only when the remote side is not implementing this
|
// method, which is impossible in normal case, because this method is
|
// automatically declared in the interface class and not implementing
|
// it in the remote side is causing compilation error. But if the remote
|
// side somehow managed to not implement it, that's an error and we
|
// report the case by returning -1 here.
|
std::ostringstream code;
|
code << "@Override\n"
|
<< "public int " << kGetInterfaceVersion << "() {\n"
|
<< " return -1;\n"
|
<< "}\n";
|
default_class->elements.emplace_back(new LiteralClassElement(code.str()));
|
}
|
}
|
}
|
|
default_class->elements.emplace_back(
|
new LiteralClassElement("@Override\n"
|
"public android.os.IBinder asBinder() {\n"
|
" return null;\n"
|
"}\n"));
|
|
return default_class;
|
}
|
|
Class* generate_binder_interface_class(const AidlInterface* iface, JavaTypeNamespace* types,
|
const Options& options) {
|
const InterfaceType* interfaceType = iface->GetLanguageType<InterfaceType>();
|
|
// the interface class
|
Class* interface = new Class;
|
interface->comment = iface->GetComments();
|
interface->modifiers = PUBLIC;
|
interface->what = Class::INTERFACE;
|
interface->type = interfaceType->JavaType();
|
interface->interfaces.push_back(types->IInterfaceType()->JavaType());
|
interface->annotations = generate_java_annotations(*iface);
|
|
if (options.Version()) {
|
std::ostringstream code;
|
code << "/**\n"
|
<< " * The version of this interface that the caller is built against.\n"
|
<< " * This might be different from what {@link #getInterfaceVersion()\n"
|
<< " * getInterfaceVersion} returns as that is the version of the interface\n"
|
<< " * that the remote object is implementing.\n"
|
<< " */\n"
|
<< "public static final int VERSION = " << options.Version() << ";\n";
|
interface->elements.emplace_back(new LiteralClassElement(code.str()));
|
}
|
|
// the default impl class
|
Class* default_impl = generate_default_impl_class(*iface, options).release();
|
interface->elements.emplace_back(default_impl);
|
|
// the stub inner class
|
StubClass* stub =
|
new StubClass(interfaceType->GetStub(), interfaceType, types, options);
|
interface->elements.push_back(stub);
|
|
compute_outline_methods(iface,
|
stub,
|
options.onTransact_outline_threshold_,
|
options.onTransact_non_outline_count_);
|
|
// the proxy inner class
|
ProxyClass* proxy = new ProxyClass(types, interfaceType->GetProxy(), interfaceType, options);
|
stub->elements.push_back(proxy);
|
|
// stub and proxy support for getInterfaceDescriptor()
|
generate_interface_descriptors(stub, proxy, types);
|
|
// all the declared constants of the interface
|
for (const auto& constant : iface->GetConstantDeclarations()) {
|
const AidlConstantValue& value = constant->GetValue();
|
|
switch (value.GetType()) {
|
case AidlConstantValue::Type::STRING: {
|
generate_string_constant(interface, constant->GetName(),
|
constant->ValueString(ConstantValueDecorator));
|
break;
|
}
|
case AidlConstantValue::Type::INTEGRAL:
|
case AidlConstantValue::Type::HEXIDECIMAL: {
|
generate_int_constant(interface, constant->GetName(),
|
constant->ValueString(ConstantValueDecorator));
|
break;
|
}
|
default: {
|
LOG(FATAL) << "Unrecognized constant type: " << static_cast<int>(value.GetType());
|
}
|
}
|
}
|
|
// all the declared methods of the interface
|
|
for (const auto& item : iface->GetMethods()) {
|
generate_methods(*iface,
|
*item,
|
interface,
|
stub,
|
proxy,
|
item->GetId(),
|
types,
|
options);
|
}
|
|
// additional static methods for the default impl set/get to the
|
// stub class. Can't add them to the interface as the generated java files
|
// may be compiled with Java < 1.7 where static interface method isn't
|
// supported.
|
// TODO(b/111417145) make this conditional depending on the Java language
|
// version requested
|
const string i_name = interfaceType->JavaType();
|
stub->elements.emplace_back(new LiteralClassElement(
|
StringPrintf("public static boolean setDefaultImpl(%s impl) {\n"
|
" if (Stub.Proxy.sDefaultImpl == null && impl != null) {\n"
|
" Stub.Proxy.sDefaultImpl = impl;\n"
|
" return true;\n"
|
" }\n"
|
" return false;\n"
|
"}\n",
|
i_name.c_str())));
|
stub->elements.emplace_back(
|
new LiteralClassElement(StringPrintf("public static %s getDefaultImpl() {\n"
|
" return Stub.Proxy.sDefaultImpl;\n"
|
"}\n",
|
i_name.c_str())));
|
|
// the static field is defined in the proxy class, not in the interface class
|
// because all fields in an interface class are by default final.
|
proxy->elements.emplace_back(new LiteralClassElement(
|
StringPrintf("public static %s sDefaultImpl;\n", i_name.c_str())));
|
|
stub->finish();
|
|
return interface;
|
}
|
|
} // namespace java
|
} // namespace android
|
} // namespace aidl
|
