blob: f03f3aa1d56583513414212ff899f3ac0efee06f [file] [log] [blame]
Andreas Huber1aec3972016-08-26 09:26:32 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Andreas Huberc9410c72016-07-28 12:18:40 -070017#include "Interface.h"
18
Zhuoyao Zhangba7e6e92016-08-10 12:19:02 -070019#include "Annotation.h"
Andreas Huberc9410c72016-07-28 12:18:40 -070020#include "Method.h"
Yifan Hong10fe0b52016-10-19 14:20:17 -070021#include "StringType.h"
22#include "VectorType.h"
Andreas Huberc9410c72016-07-28 12:18:40 -070023
Steven Moreland14ee6742016-10-18 12:58:28 -070024#include <android-base/logging.h>
Iliyan Malcheva72e0d22016-09-09 11:03:08 -070025#include <hidl-util/Formatter.h>
Yifan Hong10fe0b52016-10-19 14:20:17 -070026#include <hidl-util/StringHelper.h>
Zhuoyao Zhang864c7712016-08-16 15:35:28 -070027#include <iostream>
Yifan Hong10fe0b52016-10-19 14:20:17 -070028#include <sstream>
Zhuoyao Zhang864c7712016-08-16 15:35:28 -070029
Andreas Huberc9410c72016-07-28 12:18:40 -070030namespace android {
31
Yifan Hong10fe0b52016-10-19 14:20:17 -070032/* It is very important that these values NEVER change. These values
33 * must remain unchanged over the lifetime of android. This is
34 * because the framework on a device will be updated independently of
35 * the hals on a device. If the hals are compiled with one set of
36 * transaction values, and the framework with another, then the
37 * interface between them will be destroyed, and the device will not
38 * work.
39 */
40enum {
41 // These values are defined in hardware::IBinder.
42 /////////////////// User defined transactions
43 FIRST_CALL_TRANSACTION = 0x00000001,
44 LAST_CALL_TRANSACTION = 0x00efffff,
45 /////////////////// HIDL reserved
46 FIRST_HIDL_TRANSACTION = 0x00f00000,
47 HIDL_DESCRIPTOR_CHAIN_TRANSACTION = FIRST_HIDL_TRANSACTION,
48 LAST_HIDL_TRANSACTION = 0x00ffffff,
49};
50
Andreas Huber7c5ddfb2016-09-29 13:45:22 -070051Interface::Interface(const char *localName, Interface *super)
Andreas Huber9ed827c2016-08-22 12:31:13 -070052 : Scope(localName),
53 mSuperType(super),
Andreas Huberea081b32016-08-17 15:57:47 -070054 mIsJavaCompatibleInProgress(false) {
Yifan Hong10fe0b52016-10-19 14:20:17 -070055 mReservedMethods.push_back(createDescriptorChainMethod());
Andreas Huberc9410c72016-07-28 12:18:40 -070056}
57
Yifan Hong10fe0b52016-10-19 14:20:17 -070058Method *Interface::createDescriptorChainMethod() const {
59 VectorType *vecType = new VectorType();
60 vecType->setElementType(new StringType());
61 std::vector<TypedVar *> *results = new std::vector<TypedVar *>();
62 results->push_back(new TypedVar("indicator", vecType));
63
64 return new Method("interfaceChain",
65 new std::vector<TypedVar *>() /* args */,
66 results,
67 false /* oneway */,
68 new std::vector<Annotation *>(),
69 HIDL_DESCRIPTOR_CHAIN_TRANSACTION,
70 [this](auto &out) { /* cppImpl */
71 std::vector<const Interface *> chain = typeChain();
72 out << "::android::hardware::hidl_vec<::android::hardware::hidl_string> _hidl_return;\n";
73 out << "_hidl_return.resize(" << chain.size() << ");\n";
74 for (size_t i = 0; i < chain.size(); ++i) {
75 out << "_hidl_return[" << i << "] = \"" << chain[i]->fqName().string() << "\";\n";
76 }
77 out << "_hidl_cb(_hidl_return);\n";
78 out << "return ::android::hardware::Void();";
79 },
80 [this](auto &out) { /* javaImpl */
81 std::vector<const Interface *> chain = typeChain();
82 out << "return new ArrayList<String>(Arrays.asList(\n";
83 out.indent(); out.indent();
84 for (size_t i = 0; i < chain.size(); ++i) {
85 if (i != 0)
86 out << ",\n";
87 out << "\"" << chain[i]->fqName().string() << "\"";
88 }
89 out << "));";
90 out.unindent(); out.unindent();
91 });
92}
93
94
Steven Moreland14ee6742016-10-18 12:58:28 -070095bool Interface::addMethod(Method *method) {
Yifan Hong10fe0b52016-10-19 14:20:17 -070096 CHECK(!method->isHidlReserved());
Steven Moreland14ee6742016-10-18 12:58:28 -070097 if (lookupMethod(method->name()) != nullptr) {
98 LOG(ERROR) << "Redefinition of method " << method->name();
99 return false;
100 }
Yifan Hong10fe0b52016-10-19 14:20:17 -0700101 size_t serial = FIRST_CALL_TRANSACTION;
Steven Moreland14ee6742016-10-18 12:58:28 -0700102
Yifan Hong10fe0b52016-10-19 14:20:17 -0700103 serial += userDefinedMethods().size();
Steven Morelandef1a9fe2016-10-06 17:19:09 -0700104
Yifan Hong10fe0b52016-10-19 14:20:17 -0700105 const Interface *ancestor = mSuperType;
Steven Morelandef1a9fe2016-10-06 17:19:09 -0700106 while (ancestor != nullptr) {
Yifan Hong10fe0b52016-10-19 14:20:17 -0700107 serial += ancestor->userDefinedMethods().size();
Steven Morelandef1a9fe2016-10-06 17:19:09 -0700108 ancestor = ancestor->superType();
109 }
110
Yifan Hong10fe0b52016-10-19 14:20:17 -0700111 CHECK(serial <= LAST_CALL_TRANSACTION) << "More than "
112 << LAST_CALL_TRANSACTION << " methods are not allowed.";
Steven Morelandef1a9fe2016-10-06 17:19:09 -0700113 method->setSerialId(serial);
Yifan Hong10fe0b52016-10-19 14:20:17 -0700114 mUserMethods.push_back(method);
Steven Moreland14ee6742016-10-18 12:58:28 -0700115
116 return true;
Andreas Huberc9410c72016-07-28 12:18:40 -0700117}
118
Yifan Hong10fe0b52016-10-19 14:20:17 -0700119
Andreas Huber6cb08cf2016-08-03 15:44:51 -0700120const Interface *Interface::superType() const {
Andreas Huberc9410c72016-07-28 12:18:40 -0700121 return mSuperType;
122}
123
Yifan Hong10fe0b52016-10-19 14:20:17 -0700124std::vector<const Interface *> Interface::typeChain() const {
125 std::vector<const Interface *> v;
126 const Interface *iface = this;
127 while (iface != nullptr) {
128 v.push_back(iface);
129 iface = iface->mSuperType;
130 }
131 return v;
132}
133
Yifan Hongfe95aa22016-10-19 17:26:45 -0700134std::vector<const Interface *> Interface::superTypeChain() const {
135 return superType()->typeChain(); // should work even if superType is nullptr
136}
137
Andreas Hubera2723d22016-07-29 15:36:07 -0700138bool Interface::isInterface() const {
139 return true;
140}
141
Andreas Huber295ad302016-08-16 11:35:00 -0700142bool Interface::isBinder() const {
143 return true;
144}
145
Yifan Hong10fe0b52016-10-19 14:20:17 -0700146const std::vector<Method *> &Interface::userDefinedMethods() const {
147 return mUserMethods;
148}
149
150const std::vector<Method *> &Interface::hidlReservedMethods() const {
151 return mReservedMethods;
152}
153
154std::vector<Method *> Interface::methods() const {
155 std::vector<Method *> v(mUserMethods);
156 v.insert(v.end(), mReservedMethods.begin(), mReservedMethods.end());
157 return v;
158}
159
160std::vector<InterfaceAndMethod> Interface::allMethodsFromRoot() const {
161 std::vector<InterfaceAndMethod> v;
162 std::vector<const Interface *> chain = typeChain();
163 for (auto it = chain.rbegin(); it != chain.rend(); ++it) {
164 const Interface *iface = *it;
165 for (Method *userMethod : iface->userDefinedMethods()) {
166 v.push_back(InterfaceAndMethod(iface, userMethod));
167 }
168 }
169 for (Method *reservedMethod : hidlReservedMethods()) {
170 v.push_back(InterfaceAndMethod(this, reservedMethod));
171 }
172 return v;
Andreas Huber881227d2016-08-02 14:20:21 -0700173}
174
Steven Moreland14ee6742016-10-18 12:58:28 -0700175Method *Interface::lookupMethod(std::string name) const {
Yifan Hong10fe0b52016-10-19 14:20:17 -0700176 for (const auto &tuple : allMethodsFromRoot()) {
177 Method *method = tuple.method();
178 if (method->name() == name) {
179 return method;
Steven Moreland14ee6742016-10-18 12:58:28 -0700180 }
Steven Moreland14ee6742016-10-18 12:58:28 -0700181 }
182
183 return nullptr;
184}
185
Steven Moreland40786312016-08-16 10:29:40 -0700186std::string Interface::getBaseName() const {
Jayant Chowdhary3f32c1f2016-09-15 16:53:56 -0700187 return fqName().getInterfaceBaseName();
Steven Moreland40786312016-08-16 10:29:40 -0700188}
189
Steven Moreland979e0992016-09-07 09:18:08 -0700190std::string Interface::getCppType(StorageMode mode,
191 std::string *extra,
192 bool specifyNamespaces) const {
Andreas Huber881227d2016-08-02 14:20:21 -0700193 extra->clear();
Steven Moreland979e0992016-09-07 09:18:08 -0700194 const std::string base =
195 std::string(specifyNamespaces ? "::android::" : "")
196 + "sp<"
197 + (specifyNamespaces ? fullName() : partialCppName())
198 + ">";
Andreas Huber881227d2016-08-02 14:20:21 -0700199
200 switch (mode) {
201 case StorageMode_Stack:
202 case StorageMode_Result:
203 return base;
204
205 case StorageMode_Argument:
206 return "const " + base + "&";
207 }
208}
209
Andreas Huber4c865b72016-09-14 15:26:27 -0700210std::string Interface::getJavaType(
211 std::string *extra, bool /* forInitializer */) const {
212 extra->clear();
Andreas Huber2831d512016-08-15 09:33:47 -0700213 return fullJavaName();
214}
215
Andreas Huber881227d2016-08-02 14:20:21 -0700216void Interface::emitReaderWriter(
217 Formatter &out,
218 const std::string &name,
219 const std::string &parcelObj,
220 bool parcelObjIsPointer,
221 bool isReader,
222 ErrorMode mode) const {
223 const std::string parcelObjDeref =
224 parcelObj + (parcelObjIsPointer ? "->" : ".");
225
226 if (isReader) {
Andreas Hubere7ff2282016-08-16 13:50:03 -0700227 out << "{\n";
228 out.indent();
229
Iliyan Malchev549e2592016-08-10 08:59:12 -0700230 const std::string binderName = "_hidl_" + name + "_binder";
Andreas Huber881227d2016-08-02 14:20:21 -0700231
Andreas Huber8a82ff72016-08-04 10:29:39 -0700232 out << "::android::sp<::android::hardware::IBinder> "
Andreas Huber881227d2016-08-02 14:20:21 -0700233 << binderName << ";\n";
234
Iliyan Malchev549e2592016-08-10 08:59:12 -0700235 out << "_hidl_err = ";
Andreas Huber881227d2016-08-02 14:20:21 -0700236 out << parcelObjDeref
237 << "readNullableStrongBinder(&"
238 << binderName
239 << ");\n";
240
241 handleError(out, mode);
242
243 out << name
244 << " = "
Steven Moreland40786312016-08-16 10:29:40 -0700245 << fqName().cppNamespace()
246 << "::IHw"
247 << getBaseName()
Andreas Huber881227d2016-08-02 14:20:21 -0700248 << "::asInterface("
249 << binderName
250 << ");\n";
Andreas Hubere7ff2282016-08-16 13:50:03 -0700251
252 out.unindent();
253 out << "}\n\n";
Andreas Huber881227d2016-08-02 14:20:21 -0700254 } else {
Martijn Coenene1638232016-10-26 12:51:34 +0200255 out << "if (" << name << " == nullptr) {\n";
256 out.indent();
257 out << "_hidl_err = ";
258 out << parcelObjDeref
259 << "writeStrongBinder(nullptr);\n";
260 out.unindent();
261 out << "} else {\n";
262 out.indent();
Yifan Hong2d7126b2016-10-20 15:12:57 -0700263 out << "_hidl_err = "
264 << parcelObjDeref
265 << "writeStrongBinder("
266 << name
267 << "->toBinder());\n";
Martijn Coenene1638232016-10-26 12:51:34 +0200268 out.unindent();
269 out << "}\n";
Steven Moreland40786312016-08-16 10:29:40 -0700270
Andreas Huber881227d2016-08-02 14:20:21 -0700271 handleError(out, mode);
272 }
273}
274
Andreas Huber2831d512016-08-15 09:33:47 -0700275void Interface::emitJavaReaderWriter(
276 Formatter &out,
277 const std::string &parcelObj,
278 const std::string &argName,
279 bool isReader) const {
280 if (isReader) {
281 out << fullJavaName()
282 << ".asInterface("
283 << parcelObj
284 << ".readStrongBinder());\n";
285 } else {
286 out << parcelObj
287 << ".writeStrongBinder("
288 << argName
289 << " == null ? null : "
290 << argName
291 << ".asBinder());\n";
292 }
293}
294
Zhuoyao Zhang864c7712016-08-16 15:35:28 -0700295status_t Interface::emitVtsAttributeDeclaration(Formatter &out) const {
296 for (const auto &type : getSubTypes()) {
Zhuoyao Zhangc5ea9f52016-10-06 15:05:39 -0700297 // Skip for TypeDef as it is just an alias of a defined type.
298 if (type->isTypeDef()) {
299 continue;
300 }
Zhuoyao Zhang864c7712016-08-16 15:35:28 -0700301 out << "attribute: {\n";
302 out.indent();
303 status_t status = type->emitVtsTypeDeclarations(out);
304 if (status != OK) {
305 return status;
306 }
307 out.unindent();
308 out << "}\n\n";
309 }
310 return OK;
311}
312
313status_t Interface::emitVtsMethodDeclaration(Formatter &out) const {
Yifan Hong10fe0b52016-10-19 14:20:17 -0700314 for (const auto &method : methods()) {
Zhuoyao Zhang864c7712016-08-16 15:35:28 -0700315 out << "api: {\n";
316 out.indent();
317 out << "name: \"" << method->name() << "\"\n";
318 // Generate declaration for each return value.
319 for (const auto &result : method->results()) {
320 out << "return_type_hidl: {\n";
321 out.indent();
322 status_t status = result->type().emitVtsAttributeType(out);
323 if (status != OK) {
324 return status;
325 }
326 out.unindent();
327 out << "}\n";
328 }
329 // Generate declaration for each input argument
330 for (const auto &arg : method->args()) {
331 out << "arg: {\n";
332 out.indent();
333 status_t status = arg->type().emitVtsAttributeType(out);
334 if (status != OK) {
335 return status;
336 }
337 out.unindent();
338 out << "}\n";
339 }
340 // Generate declaration for each annotation.
Steven Morelandd537ab02016-09-12 10:32:01 -0700341 for (const auto &annotation : method->annotations()) {
Zhuoyao Zhang864c7712016-08-16 15:35:28 -0700342 out << "callflow: {\n";
343 out.indent();
Steven Morelandd537ab02016-09-12 10:32:01 -0700344 std::string name = annotation->name();
Zhuoyao Zhang864c7712016-08-16 15:35:28 -0700345 if (name == "entry") {
346 out << "entry: true\n";
347 } else if (name == "exit") {
348 out << "exit: true\n";
349 } else if (name == "callflow") {
Steven Morelandd537ab02016-09-12 10:32:01 -0700350 const AnnotationParam *param =
351 annotation->getParam("next");
352 if (param != nullptr) {
353 for (auto value : *param->getValues()) {
354 out << "next: " << value << "\n";
355 }
Zhuoyao Zhang864c7712016-08-16 15:35:28 -0700356 }
357 } else {
358 std::cerr << "Invalid annotation '"
359 << name << "' for method: " << method->name()
360 << ". Should be one of: entry, exit, callflow. \n";
361 return UNKNOWN_ERROR;
362 }
363 out.unindent();
364 out << "}\n";
365 }
366 out.unindent();
367 out << "}\n\n";
368 }
369 return OK;
370}
371
372status_t Interface::emitVtsAttributeType(Formatter &out) const {
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700373 out << "type: TYPE_HIDL_CALLBACK\n"
374 << "predefined_type: \""
375 << localName()
Zhuoyao Zhang19933522016-08-29 15:06:38 -0700376 << "\"\n"
377 << "is_callback: true\n";
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700378 return OK;
379}
380
Steven Moreland69e7c702016-09-09 11:16:32 -0700381
382bool Interface::hasOnewayMethods() const {
Yifan Hong10fe0b52016-10-19 14:20:17 -0700383 for (auto const &method : methods()) {
Steven Moreland69e7c702016-09-09 11:16:32 -0700384 if (method->isOneway()) {
385 return true;
386 }
387 }
388
389 const Interface* superClass = superType();
390
391 if (superClass != nullptr) {
392 return superClass->hasOnewayMethods();
393 }
394
395 return false;
396}
397
Andreas Huber70a59e12016-08-16 12:57:01 -0700398bool Interface::isJavaCompatible() const {
Andreas Huberea081b32016-08-17 15:57:47 -0700399 if (mIsJavaCompatibleInProgress) {
400 // We're currently trying to determine if this Interface is
401 // java-compatible and something is referencing this interface through
402 // one of its methods. Assume we'll ultimately succeed, if we were wrong
403 // the original invocation of Interface::isJavaCompatible() will then
404 // return the correct "false" result.
405 return true;
406 }
407
Andreas Huber0fa9e392016-08-31 09:05:44 -0700408 if (mSuperType != nullptr && !mSuperType->isJavaCompatible()) {
409 mIsJavaCompatibleInProgress = false;
410 return false;
411 }
412
Andreas Huberea081b32016-08-17 15:57:47 -0700413 mIsJavaCompatibleInProgress = true;
414
Andreas Huber70a59e12016-08-16 12:57:01 -0700415 if (!Scope::isJavaCompatible()) {
Andreas Huberea081b32016-08-17 15:57:47 -0700416 mIsJavaCompatibleInProgress = false;
Andreas Huber70a59e12016-08-16 12:57:01 -0700417 return false;
418 }
419
Yifan Hong10fe0b52016-10-19 14:20:17 -0700420 for (const auto &method : methods()) {
Andreas Huber70a59e12016-08-16 12:57:01 -0700421 if (!method->isJavaCompatible()) {
Andreas Huberea081b32016-08-17 15:57:47 -0700422 mIsJavaCompatibleInProgress = false;
Andreas Huber70a59e12016-08-16 12:57:01 -0700423 return false;
424 }
425 }
426
Andreas Huberea081b32016-08-17 15:57:47 -0700427 mIsJavaCompatibleInProgress = false;
428
Andreas Huber70a59e12016-08-16 12:57:01 -0700429 return true;
430}
431
Andreas Huberc9410c72016-07-28 12:18:40 -0700432} // namespace android
433