1 /* 2 * Copyright (C) 2015, 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 17 #include "tests/test_data.h" 18 19 namespace android { 20 namespace aidl { 21 namespace test_data { 22 namespace ping_responder { 23 24 const char kCanonicalName[] = "android.os.IPingResponder"; 25 const char kInterfaceDefinition[] = R"( 26 package android.os; 27 28 import bar.Unused; 29 30 interface IPingResponder { 31 String Ping(String input); 32 33 @nullable 34 String NullablePing(@nullable String input); 35 36 @utf8InCpp 37 String Utf8Ping(@utf8InCpp String input); 38 39 @utf8InCpp @nullable 40 String NullableUtf8Ping(@utf8InCpp @nullable String input); 41 } 42 )"; 43 44 const char kCppOutputPath[] = "some/path/to/output.cpp"; 45 46 const char kCppParcelableHeader[] = "cpp-header-str"; 47 48 const char* kImportedParcelables[] = { 49 "bar.Unused", 50 nullptr, 51 }; 52 53 const char* kImportedInterfaces[] = { 54 nullptr, 55 }; 56 57 const char kGenHeaderDir[] = "some/path"; 58 const char kGenInterfaceHeaderPath[] = "some/path/android/os/IPingResponder.h"; 59 const char kGenClientHeaderPath[] = "some/path/android/os/BpPingResponder.h"; 60 const char kGenServerHeaderPath[] = "some/path/android/os/BnPingResponder.h"; 61 62 const char kExpectedCppDepsOutput[] = 63 R"(some/path/to/output.cpp : \ 64 android/os/IPingResponder.aidl \ 65 ./bar/Unused.aidl 66 67 android/os/IPingResponder.aidl : 68 ./bar/Unused.aidl : 69 70 some/path/android/os/BpPingResponder.h \ 71 some/path/android/os/BnPingResponder.h \ 72 some/path/android/os/IPingResponder.h : \ 73 android/os/IPingResponder.aidl \ 74 ./bar/Unused.aidl 75 )"; 76 77 const char kExpectedCppOutput[] = 78 R"(#include <android/os/IPingResponder.h> 79 #include <android/os/BpPingResponder.h> 80 81 namespace android { 82 83 namespace os { 84 85 IMPLEMENT_META_INTERFACE(PingResponder, "android.os.IPingResponder") 86 87 ::android::IBinder* IPingResponderDefault::onAsBinder() { 88 return nullptr; 89 } 90 91 ::android::binder::Status IPingResponderDefault::Ping(const ::android::String16&, ::android::String16* ) { 92 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 93 } 94 95 ::android::binder::Status IPingResponderDefault::NullablePing(const ::std::unique_ptr<::android::String16>&, ::std::unique_ptr<::android::String16>* ) { 96 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 97 } 98 99 ::android::binder::Status IPingResponderDefault::Utf8Ping(const ::std::string&, ::std::string* ) { 100 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 101 } 102 103 ::android::binder::Status IPingResponderDefault::NullableUtf8Ping(const ::std::unique_ptr<::std::string>&, ::std::unique_ptr<::std::string>* ) { 104 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 105 } 106 107 } // namespace os 108 109 } // namespace android 110 #include <android/os/BpPingResponder.h> 111 #include <binder/Parcel.h> 112 #include <android-base/macros.h> 113 114 namespace android { 115 116 namespace os { 117 118 BpPingResponder::BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl) 119 : BpInterface<IPingResponder>(_aidl_impl){ 120 } 121 122 ::android::binder::Status BpPingResponder::Ping(const ::android::String16& input, ::android::String16* _aidl_return) { 123 ::android::Parcel _aidl_data; 124 ::android::Parcel _aidl_reply; 125 ::android::status_t _aidl_ret_status = ::android::OK; 126 ::android::binder::Status _aidl_status; 127 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 128 if (((_aidl_ret_status) != (::android::OK))) { 129 goto _aidl_error; 130 } 131 _aidl_ret_status = _aidl_data.writeString16(input); 132 if (((_aidl_ret_status) != (::android::OK))) { 133 goto _aidl_error; 134 } 135 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 0 /* Ping */, _aidl_data, &_aidl_reply); 136 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 137 return IPingResponder::getDefaultImpl()->Ping(input, _aidl_return); 138 } 139 if (((_aidl_ret_status) != (::android::OK))) { 140 goto _aidl_error; 141 } 142 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 143 if (((_aidl_ret_status) != (::android::OK))) { 144 goto _aidl_error; 145 } 146 if (!_aidl_status.isOk()) { 147 return _aidl_status; 148 } 149 _aidl_ret_status = _aidl_reply.readString16(_aidl_return); 150 if (((_aidl_ret_status) != (::android::OK))) { 151 goto _aidl_error; 152 } 153 _aidl_error: 154 _aidl_status.setFromStatusT(_aidl_ret_status); 155 return _aidl_status; 156 } 157 158 ::android::binder::Status BpPingResponder::NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) { 159 ::android::Parcel _aidl_data; 160 ::android::Parcel _aidl_reply; 161 ::android::status_t _aidl_ret_status = ::android::OK; 162 ::android::binder::Status _aidl_status; 163 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 164 if (((_aidl_ret_status) != (::android::OK))) { 165 goto _aidl_error; 166 } 167 _aidl_ret_status = _aidl_data.writeString16(input); 168 if (((_aidl_ret_status) != (::android::OK))) { 169 goto _aidl_error; 170 } 171 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 1 /* NullablePing */, _aidl_data, &_aidl_reply); 172 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 173 return IPingResponder::getDefaultImpl()->NullablePing(input, _aidl_return); 174 } 175 if (((_aidl_ret_status) != (::android::OK))) { 176 goto _aidl_error; 177 } 178 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 179 if (((_aidl_ret_status) != (::android::OK))) { 180 goto _aidl_error; 181 } 182 if (!_aidl_status.isOk()) { 183 return _aidl_status; 184 } 185 _aidl_ret_status = _aidl_reply.readString16(_aidl_return); 186 if (((_aidl_ret_status) != (::android::OK))) { 187 goto _aidl_error; 188 } 189 _aidl_error: 190 _aidl_status.setFromStatusT(_aidl_ret_status); 191 return _aidl_status; 192 } 193 194 ::android::binder::Status BpPingResponder::Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) { 195 ::android::Parcel _aidl_data; 196 ::android::Parcel _aidl_reply; 197 ::android::status_t _aidl_ret_status = ::android::OK; 198 ::android::binder::Status _aidl_status; 199 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 200 if (((_aidl_ret_status) != (::android::OK))) { 201 goto _aidl_error; 202 } 203 _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input); 204 if (((_aidl_ret_status) != (::android::OK))) { 205 goto _aidl_error; 206 } 207 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 2 /* Utf8Ping */, _aidl_data, &_aidl_reply); 208 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 209 return IPingResponder::getDefaultImpl()->Utf8Ping(input, _aidl_return); 210 } 211 if (((_aidl_ret_status) != (::android::OK))) { 212 goto _aidl_error; 213 } 214 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 215 if (((_aidl_ret_status) != (::android::OK))) { 216 goto _aidl_error; 217 } 218 if (!_aidl_status.isOk()) { 219 return _aidl_status; 220 } 221 _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); 222 if (((_aidl_ret_status) != (::android::OK))) { 223 goto _aidl_error; 224 } 225 _aidl_error: 226 _aidl_status.setFromStatusT(_aidl_ret_status); 227 return _aidl_status; 228 } 229 230 ::android::binder::Status BpPingResponder::NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) { 231 ::android::Parcel _aidl_data; 232 ::android::Parcel _aidl_reply; 233 ::android::status_t _aidl_ret_status = ::android::OK; 234 ::android::binder::Status _aidl_status; 235 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 236 if (((_aidl_ret_status) != (::android::OK))) { 237 goto _aidl_error; 238 } 239 _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input); 240 if (((_aidl_ret_status) != (::android::OK))) { 241 goto _aidl_error; 242 } 243 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 3 /* NullableUtf8Ping */, _aidl_data, &_aidl_reply); 244 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 245 return IPingResponder::getDefaultImpl()->NullableUtf8Ping(input, _aidl_return); 246 } 247 if (((_aidl_ret_status) != (::android::OK))) { 248 goto _aidl_error; 249 } 250 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 251 if (((_aidl_ret_status) != (::android::OK))) { 252 goto _aidl_error; 253 } 254 if (!_aidl_status.isOk()) { 255 return _aidl_status; 256 } 257 _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); 258 if (((_aidl_ret_status) != (::android::OK))) { 259 goto _aidl_error; 260 } 261 _aidl_error: 262 _aidl_status.setFromStatusT(_aidl_ret_status); 263 return _aidl_status; 264 } 265 266 } // namespace os 267 268 } // namespace android 269 #include <android/os/BnPingResponder.h> 270 #include <binder/Parcel.h> 271 272 namespace android { 273 274 namespace os { 275 276 ::android::status_t BnPingResponder::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { 277 ::android::status_t _aidl_ret_status = ::android::OK; 278 switch (_aidl_code) { 279 case ::android::IBinder::FIRST_CALL_TRANSACTION + 0 /* Ping */: 280 { 281 ::android::String16 in_input; 282 ::android::String16 _aidl_return; 283 if (!(_aidl_data.checkInterface(this))) { 284 _aidl_ret_status = ::android::BAD_TYPE; 285 break; 286 } 287 _aidl_ret_status = _aidl_data.readString16(&in_input); 288 if (((_aidl_ret_status) != (::android::OK))) { 289 break; 290 } 291 ::android::binder::Status _aidl_status(Ping(in_input, &_aidl_return)); 292 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 293 if (((_aidl_ret_status) != (::android::OK))) { 294 break; 295 } 296 if (!_aidl_status.isOk()) { 297 break; 298 } 299 _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); 300 if (((_aidl_ret_status) != (::android::OK))) { 301 break; 302 } 303 } 304 break; 305 case ::android::IBinder::FIRST_CALL_TRANSACTION + 1 /* NullablePing */: 306 { 307 ::std::unique_ptr<::android::String16> in_input; 308 ::std::unique_ptr<::android::String16> _aidl_return; 309 if (!(_aidl_data.checkInterface(this))) { 310 _aidl_ret_status = ::android::BAD_TYPE; 311 break; 312 } 313 _aidl_ret_status = _aidl_data.readString16(&in_input); 314 if (((_aidl_ret_status) != (::android::OK))) { 315 break; 316 } 317 ::android::binder::Status _aidl_status(NullablePing(in_input, &_aidl_return)); 318 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 319 if (((_aidl_ret_status) != (::android::OK))) { 320 break; 321 } 322 if (!_aidl_status.isOk()) { 323 break; 324 } 325 _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); 326 if (((_aidl_ret_status) != (::android::OK))) { 327 break; 328 } 329 } 330 break; 331 case ::android::IBinder::FIRST_CALL_TRANSACTION + 2 /* Utf8Ping */: 332 { 333 ::std::string in_input; 334 ::std::string _aidl_return; 335 if (!(_aidl_data.checkInterface(this))) { 336 _aidl_ret_status = ::android::BAD_TYPE; 337 break; 338 } 339 _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input); 340 if (((_aidl_ret_status) != (::android::OK))) { 341 break; 342 } 343 ::android::binder::Status _aidl_status(Utf8Ping(in_input, &_aidl_return)); 344 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 345 if (((_aidl_ret_status) != (::android::OK))) { 346 break; 347 } 348 if (!_aidl_status.isOk()) { 349 break; 350 } 351 _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); 352 if (((_aidl_ret_status) != (::android::OK))) { 353 break; 354 } 355 } 356 break; 357 case ::android::IBinder::FIRST_CALL_TRANSACTION + 3 /* NullableUtf8Ping */: 358 { 359 ::std::unique_ptr<::std::string> in_input; 360 ::std::unique_ptr<::std::string> _aidl_return; 361 if (!(_aidl_data.checkInterface(this))) { 362 _aidl_ret_status = ::android::BAD_TYPE; 363 break; 364 } 365 _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input); 366 if (((_aidl_ret_status) != (::android::OK))) { 367 break; 368 } 369 ::android::binder::Status _aidl_status(NullableUtf8Ping(in_input, &_aidl_return)); 370 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 371 if (((_aidl_ret_status) != (::android::OK))) { 372 break; 373 } 374 if (!_aidl_status.isOk()) { 375 break; 376 } 377 _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); 378 if (((_aidl_ret_status) != (::android::OK))) { 379 break; 380 } 381 } 382 break; 383 default: 384 { 385 _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); 386 } 387 break; 388 } 389 if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { 390 _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply); 391 } 392 return _aidl_ret_status; 393 } 394 395 } // namespace os 396 397 } // namespace android 398 )"; 399 400 const char kExpectedIHeaderOutput[] = 401 R"(#ifndef AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_ 402 #define AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_ 403 404 #include <binder/IBinder.h> 405 #include <binder/IInterface.h> 406 #include <binder/Status.h> 407 #include <memory> 408 #include <string> 409 #include <utils/String16.h> 410 #include <utils/StrongPointer.h> 411 412 namespace android { 413 414 namespace os { 415 416 class IPingResponder : public ::android::IInterface { 417 public: 418 DECLARE_META_INTERFACE(PingResponder) 419 virtual ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) = 0; 420 virtual ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) = 0; 421 virtual ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) = 0; 422 virtual ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) = 0; 423 }; // class IPingResponder 424 425 class IPingResponderDefault : public IPingResponder { 426 public: 427 ::android::IBinder* onAsBinder() override; 428 ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) override; 429 ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) override; 430 ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) override; 431 ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) override; 432 433 }; 434 435 } // namespace os 436 437 } // namespace android 438 439 #endif // AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_ 440 )"; 441 442 const char kExpectedBpHeaderOutput[] = 443 R"(#ifndef AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_ 444 #define AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_ 445 446 #include <binder/IBinder.h> 447 #include <binder/IInterface.h> 448 #include <utils/Errors.h> 449 #include <android/os/IPingResponder.h> 450 451 namespace android { 452 453 namespace os { 454 455 class BpPingResponder : public ::android::BpInterface<IPingResponder> { 456 public: 457 explicit BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl); 458 virtual ~BpPingResponder() = default; 459 ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) override; 460 ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) override; 461 ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) override; 462 ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) override; 463 }; // class BpPingResponder 464 465 } // namespace os 466 467 } // namespace android 468 469 #endif // AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_ 470 )"; 471 472 const char kExpectedBnHeaderOutput[] = 473 R"(#ifndef AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_ 474 #define AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_ 475 476 #include <binder/IInterface.h> 477 #include <android/os/IPingResponder.h> 478 479 namespace android { 480 481 namespace os { 482 483 class BnPingResponder : public ::android::BnInterface<IPingResponder> { 484 public: 485 ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; 486 }; // class BnPingResponder 487 488 } // namespace os 489 490 } // namespace android 491 492 #endif // AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_ 493 )"; 494 495 const char kExpectedCppOutputWithVersion[] = 496 R"(#include <android/os/IPingResponder.h> 497 #include <android/os/BpPingResponder.h> 498 499 namespace android { 500 501 namespace os { 502 503 IMPLEMENT_META_INTERFACE(PingResponder, "android.os.IPingResponder") 504 505 ::android::IBinder* IPingResponderDefault::onAsBinder() { 506 return nullptr; 507 } 508 509 ::android::binder::Status IPingResponderDefault::Ping(const ::android::String16&, ::android::String16* ) { 510 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 511 } 512 513 ::android::binder::Status IPingResponderDefault::NullablePing(const ::std::unique_ptr<::android::String16>&, ::std::unique_ptr<::android::String16>* ) { 514 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 515 } 516 517 ::android::binder::Status IPingResponderDefault::Utf8Ping(const ::std::string&, ::std::string* ) { 518 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 519 } 520 521 ::android::binder::Status IPingResponderDefault::NullableUtf8Ping(const ::std::unique_ptr<::std::string>&, ::std::unique_ptr<::std::string>* ) { 522 return ::android::binder::Status::fromStatusT(::android::UNKNOWN_TRANSACTION); 523 } 524 525 int32_t IPingResponderDefault::getInterfaceVersion() { 526 return 0; 527 } 528 529 } // namespace os 530 531 } // namespace android 532 #include <android/os/BpPingResponder.h> 533 #include <binder/Parcel.h> 534 #include <android-base/macros.h> 535 536 namespace android { 537 538 namespace os { 539 540 BpPingResponder::BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl) 541 : BpInterface<IPingResponder>(_aidl_impl){ 542 } 543 544 ::android::binder::Status BpPingResponder::Ping(const ::android::String16& input, ::android::String16* _aidl_return) { 545 ::android::Parcel _aidl_data; 546 ::android::Parcel _aidl_reply; 547 ::android::status_t _aidl_ret_status = ::android::OK; 548 ::android::binder::Status _aidl_status; 549 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 550 if (((_aidl_ret_status) != (::android::OK))) { 551 goto _aidl_error; 552 } 553 _aidl_ret_status = _aidl_data.writeString16(input); 554 if (((_aidl_ret_status) != (::android::OK))) { 555 goto _aidl_error; 556 } 557 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 0 /* Ping */, _aidl_data, &_aidl_reply); 558 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 559 return IPingResponder::getDefaultImpl()->Ping(input, _aidl_return); 560 } 561 if (((_aidl_ret_status) != (::android::OK))) { 562 goto _aidl_error; 563 } 564 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 565 if (((_aidl_ret_status) != (::android::OK))) { 566 goto _aidl_error; 567 } 568 if (!_aidl_status.isOk()) { 569 return _aidl_status; 570 } 571 _aidl_ret_status = _aidl_reply.readString16(_aidl_return); 572 if (((_aidl_ret_status) != (::android::OK))) { 573 goto _aidl_error; 574 } 575 _aidl_error: 576 _aidl_status.setFromStatusT(_aidl_ret_status); 577 return _aidl_status; 578 } 579 580 ::android::binder::Status BpPingResponder::NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) { 581 ::android::Parcel _aidl_data; 582 ::android::Parcel _aidl_reply; 583 ::android::status_t _aidl_ret_status = ::android::OK; 584 ::android::binder::Status _aidl_status; 585 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 586 if (((_aidl_ret_status) != (::android::OK))) { 587 goto _aidl_error; 588 } 589 _aidl_ret_status = _aidl_data.writeString16(input); 590 if (((_aidl_ret_status) != (::android::OK))) { 591 goto _aidl_error; 592 } 593 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 1 /* NullablePing */, _aidl_data, &_aidl_reply); 594 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 595 return IPingResponder::getDefaultImpl()->NullablePing(input, _aidl_return); 596 } 597 if (((_aidl_ret_status) != (::android::OK))) { 598 goto _aidl_error; 599 } 600 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 601 if (((_aidl_ret_status) != (::android::OK))) { 602 goto _aidl_error; 603 } 604 if (!_aidl_status.isOk()) { 605 return _aidl_status; 606 } 607 _aidl_ret_status = _aidl_reply.readString16(_aidl_return); 608 if (((_aidl_ret_status) != (::android::OK))) { 609 goto _aidl_error; 610 } 611 _aidl_error: 612 _aidl_status.setFromStatusT(_aidl_ret_status); 613 return _aidl_status; 614 } 615 616 ::android::binder::Status BpPingResponder::Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) { 617 ::android::Parcel _aidl_data; 618 ::android::Parcel _aidl_reply; 619 ::android::status_t _aidl_ret_status = ::android::OK; 620 ::android::binder::Status _aidl_status; 621 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 622 if (((_aidl_ret_status) != (::android::OK))) { 623 goto _aidl_error; 624 } 625 _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input); 626 if (((_aidl_ret_status) != (::android::OK))) { 627 goto _aidl_error; 628 } 629 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 2 /* Utf8Ping */, _aidl_data, &_aidl_reply); 630 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 631 return IPingResponder::getDefaultImpl()->Utf8Ping(input, _aidl_return); 632 } 633 if (((_aidl_ret_status) != (::android::OK))) { 634 goto _aidl_error; 635 } 636 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 637 if (((_aidl_ret_status) != (::android::OK))) { 638 goto _aidl_error; 639 } 640 if (!_aidl_status.isOk()) { 641 return _aidl_status; 642 } 643 _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); 644 if (((_aidl_ret_status) != (::android::OK))) { 645 goto _aidl_error; 646 } 647 _aidl_error: 648 _aidl_status.setFromStatusT(_aidl_ret_status); 649 return _aidl_status; 650 } 651 652 ::android::binder::Status BpPingResponder::NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) { 653 ::android::Parcel _aidl_data; 654 ::android::Parcel _aidl_reply; 655 ::android::status_t _aidl_ret_status = ::android::OK; 656 ::android::binder::Status _aidl_status; 657 _aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor()); 658 if (((_aidl_ret_status) != (::android::OK))) { 659 goto _aidl_error; 660 } 661 _aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input); 662 if (((_aidl_ret_status) != (::android::OK))) { 663 goto _aidl_error; 664 } 665 _aidl_ret_status = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 3 /* NullableUtf8Ping */, _aidl_data, &_aidl_reply); 666 if (UNLIKELY(_aidl_ret_status == ::android::UNKNOWN_TRANSACTION && IPingResponder::getDefaultImpl())) { 667 return IPingResponder::getDefaultImpl()->NullableUtf8Ping(input, _aidl_return); 668 } 669 if (((_aidl_ret_status) != (::android::OK))) { 670 goto _aidl_error; 671 } 672 _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply); 673 if (((_aidl_ret_status) != (::android::OK))) { 674 goto _aidl_error; 675 } 676 if (!_aidl_status.isOk()) { 677 return _aidl_status; 678 } 679 _aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return); 680 if (((_aidl_ret_status) != (::android::OK))) { 681 goto _aidl_error; 682 } 683 _aidl_error: 684 _aidl_status.setFromStatusT(_aidl_ret_status); 685 return _aidl_status; 686 } 687 688 int32_t BpPingResponder::getInterfaceVersion() { 689 if (cached_version_ == -1) { 690 ::android::Parcel data; 691 ::android::Parcel reply; 692 data.writeInterfaceToken(getInterfaceDescriptor()); 693 ::android::status_t err = remote()->transact(::android::IBinder::FIRST_CALL_TRANSACTION + 16777214 /* getInterfaceVersion */, data, &reply); 694 if (err == ::android::OK) { 695 ::android::binder::Status _aidl_status; 696 err = _aidl_status.readFromParcel(reply); 697 if (err == ::android::OK && _aidl_status.isOk()) { 698 cached_version_ = reply.readInt32(); 699 } 700 } 701 } 702 return cached_version_; 703 } 704 705 } // namespace os 706 707 } // namespace android 708 #include <android/os/BnPingResponder.h> 709 #include <binder/Parcel.h> 710 711 namespace android { 712 713 namespace os { 714 715 ::android::status_t BnPingResponder::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) { 716 ::android::status_t _aidl_ret_status = ::android::OK; 717 switch (_aidl_code) { 718 case ::android::IBinder::FIRST_CALL_TRANSACTION + 0 /* Ping */: 719 { 720 ::android::String16 in_input; 721 ::android::String16 _aidl_return; 722 if (!(_aidl_data.checkInterface(this))) { 723 _aidl_ret_status = ::android::BAD_TYPE; 724 break; 725 } 726 _aidl_ret_status = _aidl_data.readString16(&in_input); 727 if (((_aidl_ret_status) != (::android::OK))) { 728 break; 729 } 730 ::android::binder::Status _aidl_status(Ping(in_input, &_aidl_return)); 731 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 732 if (((_aidl_ret_status) != (::android::OK))) { 733 break; 734 } 735 if (!_aidl_status.isOk()) { 736 break; 737 } 738 _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); 739 if (((_aidl_ret_status) != (::android::OK))) { 740 break; 741 } 742 } 743 break; 744 case ::android::IBinder::FIRST_CALL_TRANSACTION + 1 /* NullablePing */: 745 { 746 ::std::unique_ptr<::android::String16> in_input; 747 ::std::unique_ptr<::android::String16> _aidl_return; 748 if (!(_aidl_data.checkInterface(this))) { 749 _aidl_ret_status = ::android::BAD_TYPE; 750 break; 751 } 752 _aidl_ret_status = _aidl_data.readString16(&in_input); 753 if (((_aidl_ret_status) != (::android::OK))) { 754 break; 755 } 756 ::android::binder::Status _aidl_status(NullablePing(in_input, &_aidl_return)); 757 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 758 if (((_aidl_ret_status) != (::android::OK))) { 759 break; 760 } 761 if (!_aidl_status.isOk()) { 762 break; 763 } 764 _aidl_ret_status = _aidl_reply->writeString16(_aidl_return); 765 if (((_aidl_ret_status) != (::android::OK))) { 766 break; 767 } 768 } 769 break; 770 case ::android::IBinder::FIRST_CALL_TRANSACTION + 2 /* Utf8Ping */: 771 { 772 ::std::string in_input; 773 ::std::string _aidl_return; 774 if (!(_aidl_data.checkInterface(this))) { 775 _aidl_ret_status = ::android::BAD_TYPE; 776 break; 777 } 778 _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input); 779 if (((_aidl_ret_status) != (::android::OK))) { 780 break; 781 } 782 ::android::binder::Status _aidl_status(Utf8Ping(in_input, &_aidl_return)); 783 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 784 if (((_aidl_ret_status) != (::android::OK))) { 785 break; 786 } 787 if (!_aidl_status.isOk()) { 788 break; 789 } 790 _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); 791 if (((_aidl_ret_status) != (::android::OK))) { 792 break; 793 } 794 } 795 break; 796 case ::android::IBinder::FIRST_CALL_TRANSACTION + 3 /* NullableUtf8Ping */: 797 { 798 ::std::unique_ptr<::std::string> in_input; 799 ::std::unique_ptr<::std::string> _aidl_return; 800 if (!(_aidl_data.checkInterface(this))) { 801 _aidl_ret_status = ::android::BAD_TYPE; 802 break; 803 } 804 _aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input); 805 if (((_aidl_ret_status) != (::android::OK))) { 806 break; 807 } 808 ::android::binder::Status _aidl_status(NullableUtf8Ping(in_input, &_aidl_return)); 809 _aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply); 810 if (((_aidl_ret_status) != (::android::OK))) { 811 break; 812 } 813 if (!_aidl_status.isOk()) { 814 break; 815 } 816 _aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return); 817 if (((_aidl_ret_status) != (::android::OK))) { 818 break; 819 } 820 } 821 break; 822 case ::android::IBinder::FIRST_CALL_TRANSACTION + 16777214 /* getInterfaceVersion */: 823 { 824 _aidl_data.checkInterface(this); 825 _aidl_reply->writeNoException(); 826 _aidl_reply->writeInt32(IPingResponder::VERSION); 827 } 828 break; 829 default: 830 { 831 _aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags); 832 } 833 break; 834 } 835 if (_aidl_ret_status == ::android::UNEXPECTED_NULL) { 836 _aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply); 837 } 838 return _aidl_ret_status; 839 } 840 841 int32_t BnPingResponder::getInterfaceVersion() { 842 return IPingResponder::VERSION; 843 } 844 845 } // namespace os 846 847 } // namespace android 848 )"; 849 850 const char kExpectedIHeaderOutputWithVersion[] = 851 R"(#ifndef AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_ 852 #define AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_ 853 854 #include <binder/IBinder.h> 855 #include <binder/IInterface.h> 856 #include <binder/Status.h> 857 #include <memory> 858 #include <string> 859 #include <utils/String16.h> 860 #include <utils/StrongPointer.h> 861 862 namespace android { 863 864 namespace os { 865 866 class IPingResponder : public ::android::IInterface { 867 public: 868 DECLARE_META_INTERFACE(PingResponder) 869 const int32_t VERSION = 10; 870 virtual ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) = 0; 871 virtual ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) = 0; 872 virtual ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) = 0; 873 virtual ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) = 0; 874 virtual int32_t getInterfaceVersion() = 0; 875 }; // class IPingResponder 876 877 class IPingResponderDefault : public IPingResponder { 878 public: 879 ::android::IBinder* onAsBinder() override; 880 ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) override; 881 ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) override; 882 ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) override; 883 ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) override; 884 int32_t getInterfaceVersion() override; 885 886 }; 887 888 } // namespace os 889 890 } // namespace android 891 892 #endif // AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_ 893 )"; 894 895 const char kExpectedBpHeaderOutputWithVersion[] = 896 R"(#ifndef AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_ 897 #define AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_ 898 899 #include <binder/IBinder.h> 900 #include <binder/IInterface.h> 901 #include <utils/Errors.h> 902 #include <android/os/IPingResponder.h> 903 904 namespace android { 905 906 namespace os { 907 908 class BpPingResponder : public ::android::BpInterface<IPingResponder> { 909 public: 910 explicit BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl); 911 virtual ~BpPingResponder() = default; 912 ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) override; 913 ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) override; 914 ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) override; 915 ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) override; 916 int32_t getInterfaceVersion() override; 917 private: 918 int32_t cached_version_ = -1; 919 }; // class BpPingResponder 920 921 } // namespace os 922 923 } // namespace android 924 925 #endif // AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_ 926 )"; 927 928 const char kExpectedBnHeaderOutputWithVersion[] = 929 R"(#ifndef AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_ 930 #define AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_ 931 932 #include <binder/IInterface.h> 933 #include <android/os/IPingResponder.h> 934 935 namespace android { 936 937 namespace os { 938 939 class BnPingResponder : public ::android::BnInterface<IPingResponder> { 940 public: 941 ::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) override; 942 int32_t getInterfaceVersion() final override; 943 }; // class BnPingResponder 944 945 } // namespace os 946 947 } // namespace android 948 949 #endif // AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_ 950 )"; 951 952 } // namespace ping_responder 953 } // namespace test_data 954 } // namespace aidl 955 } // namespace android 956